(1*0+11*)+(0(0|1)*) 

>> email_string = "mike@gmail.com, yadu@yahoo.org, chris@hotmail.edu"# Say I want to find the domains (i.e., domain.com) in test_string
>> import re
>> re.findall( r'(?<=@)[A-z]+.[com|net|org|edu]*', email_string )['gmail.com', 'yahoo.org', 'hotmail.edu']

$ cat employees.txt
Name          Phone Number    Undergraduate School
Michael R     202 123 4567    Virginia Tech
Yadu R        703 321 4567    University of Virginia
Chris S       301 987 4567    CalTech
$ grep -o '^[A-z ][A-z ]*[0-9]\{3\} ' employees.txt | sed 's/[A-z ]*//g' | sort -u
202
301
703

let x = 5 in {
  print (x + 1)
};

 LET
 IDENTIFIER x
 EQ
 INTEGER 5
 IN
 LBRACE
 IDENTIFIER print
 LPAREN
 IDENTIFIER x
 PLUS
 INTEGER 1
 RPAREN
 RBRACE
 SEMICOLON

 balanced( "(())" ) #=> should return true
 balanced( "))((" ) #=> should return false
 balanced( "())"  ) #=> should return false
 balanced( "(()"  ) #=> should return false
 balanced( "(()()(())((((((()))))))())" ) #=> should return true

%start expressions
%%
expressions
    : e EOF
        {return $1;}
    ;

e
    : e '+' e
        {$$ = $1+$3;}
    | e '-' e
        {$$ = $1-$3;}
    | e '*' e
        {$$ = $1*$3;}
    | e '/' e
        {$$ = $1/$3;}
    | '(' e ')'
        {$$ = $2;}
    | INTEGER
        {$$ = Number(yytext);}
    ;

%{
open Imp		    

let error msg	= failwith msg
%}

%token <string>         IDENTIFIER
%token <int>            INT

%token PLUS 
%token MINUS 
%token TIMES 
%token TRUE
%token FALSE
%token EQ_TOK
%token LE_TOK
%token NOT
%token AND
%token OR 
%token SKIP
%token SET 
%token SEMICOLON
%token IF
%token THEN
%token ELSE
%token WHILE
%token DO 
%token LET
%token IN
%token PRINT
%token LPAREN
%token RPAREN
%token LBRACE
%token RBRACE

%token EOF

%start com
%type <Imp.com> com

%left AND
%left OR
%left PLUS MINUS
%left TIMES
%left LE_TOK EQ_TOK
%nonassoc NOT

%%

aexp : INT                                   { Const($1) }
| IDENTIFIER                                 { Var($1) }
| aexp PLUS aexp                             { Add($1,$3) } 
| aexp MINUS aexp                            { Sub($1,$3) } 
| aexp TIMES aexp                            { Mul($1,$3) } 
| LPAREN aexp RPAREN                         { $2 } 
;

bexp : TRUE                                  { True }
| FALSE                                      { False }
| aexp EQ_TOK aexp                           { EQ($1,$3) }
| aexp LE_TOK aexp                           { LE($1,$3) }
| NOT bexp                                   { Not($2) }
| bexp AND bexp                              { And($1,$3) }
| bexp OR bexp                               { Or($1,$3) }
;

com : SKIP                                   { Skip }
| IDENTIFIER SET aexp                        { Set($1,$3) } 
| com SEMICOLON com                          { Seq($1,$3) }
| IF bexp THEN com ELSE com                  { If($2,$4,$6) }
| WHILE bexp DO com                          { While($2,$4) }
| LET IDENTIFIER EQ_TOK aexp IN com          { Let($2,$4,$6) }
| PRINT aexp                                 { Print($2) }
| LBRACE com RBRACE                          { $2 } 
;

"If expression e ₁ has type real in environment Γ and e ₂ has type real in environment Γ, then the expression e ₁ + e ₂ will have an environment Γ and type real.

 let x = 1 in
   let y = x + 1 in
     let z = y + 3 in
       print_int z
 ;;

 addi $r1, $r2, $r3 # addi is add immediate; $r1 = $r2 + $r3

(*      
 * Our operational semantics has a notion of 'state' (sigma). The type
 * 'state' is a side-effect-ful mapping from 'loc' to 'n'.
 * 
 * See http://caml.inria.fr/pub/docs/manual-ocaml/libref/Hashtbl.html
 *)
type state = (loc, n) Hashtbl.t

let initial_state () : state = Hashtbl.create 255 

(* Given a state sigma, return the current value associated with
 * 'variable'. For our purposes all uninitialized variables start at 0. *)
let lookup (sigma:state) (variable:loc) : n = 
  try
    Hashtbl.find sigma variable 
  with Not_found -> 0 

(* Evaluates an aexp given the state 'sigma'. *) 
let rec eval_aexp (a:aexp) (sigma:state) : n = match a with
  | Const(n) -> n
  | Var(loc) -> lookup sigma loc 
  | Add(a0,a1) -> 
    let n0 = eval_aexp a0 sigma in
    let n1 = eval_aexp a1 sigma in
    n0 + n1
  | Sub(a0,a1) -> 
    let n0 = eval_aexp a0 sigma in
    let n1 = eval_aexp a1 sigma in
    n0 - n1
  | Mul(a0,a1) -> 
    let n0 = eval_aexp a0 sigma in
    let n1 = eval_aexp a1 sigma in
    n0 * n1

(* Evaluates a bexp given the state 'sigma'. *) 
let rec eval_bexp (b:bexp) (sigma:state) : t = match b with
  | True -> true
  | False -> false 
  | EQ(a0,a1) ->
    let n0 = eval_aexp a0 sigma in
    let n1 = eval_aexp a1 sigma in
    n0 = n1
  | LE(a0,a1) ->
    let n0 = eval_aexp a0 sigma in
    let n1 = eval_aexp a1 sigma in
    n0 <= n1
  | Not(b) ->
    not (eval_bexp b sigma)
  | And(b0,b1) ->
    let n0 = eval_bexp b0 sigma in
    let n1 = eval_bexp b1 sigma in
    n0 && n1
  | Or(b0,b1) ->
    let n0 = eval_bexp b0 sigma in
    let n1 = eval_bexp b1 sigma in
    n0 || n1

(* Evaluates a com given the state 'sigma'. *) 
let rec eval_com (c:com) (sigma:state) : state = match c with
  | Skip -> sigma
  | Set(l,a) ->
    let n = eval_aexp a sigma in
    Hashtbl.add sigma l n;
    sigma
  | Seq(c0,c1) ->
    let new_sigma = eval_com c0 sigma in
    eval_com c1 new_sigma
  | If(b,c0,c1) ->
    if eval_bexp b sigma then
      eval_com c0 sigma
    else
      eval_com c1 sigma
  | While(b,c) ->
    if not (eval_bexp b sigma) then
      sigma
    else begin
      let new_sigma = eval_com c sigma in
      let new_c = While(b,c) in
      eval_com new_c new_sigma
    end
  | Let(l,a,c) ->
    let original_n = lookup sigma l in
    let n = eval_aexp a sigma in
    Hashtbl.add sigma l n;
    let new_sigma = eval_com c sigma in
    Hashtbl.replace new_sigma l original_n;
    new_sigma
  | Print(a) -> 
    Printf.printf "%d" (eval_aexp a sigma);
    sigma
            
        

 let x = 5 in {
   print x + 1
 }

 mov   %eax, 5  ; read this as "move 5 into %eax"
 inc   %eax     ; the same as  "add %eax, 1"
 push  %eax     ; pushing %eax to the stack so it will be available by the callee "_print"
 call  _print   ; call the internal assembly method to print the contents of %eax

 # Intermediate Level 2 - optimized version 
 x := 5 
 print "Hello" 
 x := x + 1 
 print x

 # Intermediate Level 3 - further optimized version 
 print "Hello" 
 print 6

• conditional branching ("if", "goto", "branch if zero")
• ability to change an arbitrary amount of memory locations