Pattern matching

[arshajii]

Typical pattern matching from e.g. OCaml or Rust should be fairly easy to implement.

More interesting is pattern matching for sequence types. Many sequence computations can potentially be expressed with this. For example, a simple hash function:

fun hash(s: Seq) -> Int:
  s match A t => 0 + 4*hash(t)
        | C t => 1 + 4*hash(t)
        | G t => 2 + 4*hash(t)
        | T t => 3 + 4*hash(t)
        | _   => 0

[arshajii]

This works now (see seq-matching).

Example code:

fun hash(s: Seq) -> Int {
  match s {
    case `A...`: return 0 + 4*hash(s[1:])
    case `C...`: return 1 + 4*hash(s[1:])
    case `G...`: return 2 + 4*hash(s[1:])
    case `T...`: return 3 + 4*hash(s[1:])
    case ``: return 0
  }
}

source args[0] as input {
  let s = input[:5]
  s |> print
  hash(s) |> print
}

Example output

GTGCA
110
TATAT
819
CCTGC
437
TCAAT
775

[arshajii]

Another example:

fun has_N(s: Seq) -> Bool {
  match s {
    case ``: return false
    case `N...`: return true
    case `_...`: return has_n(s[1:])
  }
}