Basic Types

Type Values Description
Atom :ok, :error Erlang Atom type
Boolean(Bool) true \ false Boolean type
Char ‘c’, ‘x’ UTF-8 character
String “hello” List of UTF-8 character
Integer(Int) 1, 2, -10 Integer type
Float(Double) 3.14 Float type
List
Tuple (1, true)
Map #{“k” => “v”} Erlang Map
Record
Binary <<1,2,3>> Erlang Binary/Bitstring
Pid Erlang Pid
Port Erlang Port
Reference(Ref) Erlang Reference

Booleans

  1. true || false

Integers and Floats

Two types of numeric literals: Integers and Floats.

  1. -- Integer
  2. 1, 2, -10
  4. -- binary, octal, and hex literals
  5. 0x1, 0X1, 0x2a, 0X2A
  6. 0o1, 0O1, 0o52, 0O52
  7. 0b10, 0B10
  9. -- floats
  10. 1.0, 1e10
  11. 2.3
  12. 2.3e-3
  13. 0.0023

Atoms

In Hamler, atoms start with ‘:’, and correspond to Erlang atoms.

  1. :atom, :ok, :error

Chars

UTF-8 Unicode characters.

  1. 'a', 'b', 'の'

Strings

In Hamler, a string is a list of UTF-8 Unicode characters.

  1. "Hello, World!"
  2. "你好，世界"
  3. "ハロー、ワールド"
  5. -- Escape Codes
  6. "\r\n ..."
  8. -- ++ to concat strings
  9. "Hello " ++ " World"
  11. -- TODO
  12. printf "foo %s" "bar"

Tuples

A tuple is a sequence of values of different types. In Hamler, the maximum length of the tuple is 7.

  1. (1, "a", true)
  2. (1, "a")
  4. -- fst, snd
  5. fst (1, 'a') :: Integer -- 1
  6. snd (1, 'a') :: Char    -- 'a'

Lists

A list is sequence of values of the same type:

  1. {-- List --}
  2. [] -- empty list
  3. [1,2,3] -- Integer list
  5. [1|[2,3]] -- Cons
  6. [1|[2|[3|[]]]] -- Cons
  8. [x|_] = [1,2,3] -- List pattern
  9. [_|xs] = [1,2,3] -- List pattern
  10. [x|xs] -- Cons

Maps

Erlang-style maps are available in Hamler:

  1. -- New map; all keys must have the same type, and all values must have the same type.
  2. m = #{:foo => "foo", :bar => "bar"}
  4. -- Pattern matching
  5. #{:foo := a, :bar := b} = m
  6. a :: String -- "foo"
  7. b :: String -- "bar"
  9. -- get, put
  10. import Data.Map as Map
  11. m1 = Map.put :key "val"
  12. Map.get :foo m :: String -- "foo"
  13. Map.get :key m1 :: String -- "val"
  15. -- keys, values
  16. keys   = Map.keys   m -- [String]
  17. values = Map.values m -- [String]

Records

  1. -- declare a Person record
  2. type Person = {name :: String, age :: Integer}
  4. -- create a Person record
  5. p = {name = "John", age = 12}
  7. -- update a Person record
  8. p1 = p{name = "Miles", age = 20}
  10. -- accessors
  11. name = p1.name :: String
  12. age = p1.age   :: Integer

Binaries

Binaries are imported from Erlang, which are raw byte strings.

  1. -- Construct Binary
  2. <<127,0,0,1>>
  3. <<"ABC">>
  4. <<1:16,2:4,3:4>>
  6. -- Binary Pattern Match
  7. <<x:3,y:5,z:8>> = <<1,0>>
  8. <<bigI:16:Big-Unsigned-Integer>> = <<1,2>>
  9. <<litI:16:Little-Signed-Integer>> = <<1,2>>

Ports

TODO: Erlang port identifier identifies an Erlang port.

PIDs

TODO: Erlang process identifier, pid, identifies a process.

References

TODO: Erlang reference