{% switch %} statement about jingoo HOT 13 CLOSED

Hmm, in my rough understanding, statement structure will be like bellow?

SwitchStatement of expr * (tvalue, ast) list * ast option

and if switch case is like

switch(expr){
  case "foo":
  case "bar": ast1
  case 100: ast2
  default: ast3
}

it becomes

SwitchStatement(
  expr, [
    (Tstr "foo", ast1); (* case label "foo" *)
    (Tstr "bar", ast1); (* case label "bar" *)
    (Tint 100, ast2);   (* case label 100 *)
], Some ast3) (* default *)

then expr is evaluated only once(unlike if else statement), and matched case is searched by

let value = value_of_expr env ctx expr in
if jg_eq_eq value (Tstr "foo") then ast1
else if jg_eq_eq value (Tint 100) then ast2
else match ast3 with Some ast3 -> ast3 | None -> []

Both expr value and label value of case are tvalue, then we can compare them by using jg_eq_eq.

Is it the "pattern matching" you said?

from jingoo.

See geneanet@1d220ad for a first draft. It does not handle multiple case evaluating to same value yet.

from jingoo.

Thanks for reference, I've read it, compact and beautiful implementation!

from jingoo.

With geneanet@c026c28

You can use {% case foo || bar || baz %}. What do you think about this syntax?

from jingoo.

After reading code, I can understand the meaning easily, but in first look, foo || bar || baz part seems like boolean value?

if ((foo || bar || baz) === true){ ... }

But it's my own feeling...

from jingoo.

I should have written

{% switch x %}
  {% case "foo" || "bar" || "baz" %}{{ ... }}
  {% default %} {{ ... }}
{% endswitch %}

from jingoo.

Are case values allowed for direct value only?

In current impl, it seems it can be variable.

SwitchStatement of expression * (expression list * ast) list

If only for direct value, this should be like this?

SwitchStatement of expression * (tvalue list * ast) list

from jingoo.

But if it's only allowed for direct values, {% case "foo" || "bar" || "baz" %} seems short and good syntax.

from jingoo.

I am actually using it with variable in my code.

{%- set T_ROOT = 0 -%}
...
{%- set T_WITNESS = 7 -%}
{%- set T_GODPARENT = 8 -%}

...

  {%- switch r -%}
    {% case T_ROOT || T_WITNESS || T_GODPARENT %}{{ ... }}
    {%- default -%}{{... }}
  {%- endswitch -%}

Would you say that {% case "foo" case "bar" case "baz" %} would be a better/good choice. Or something else?

from jingoo.

What I worry about is confliction like this,

{% set a = false %}
{% set b = true %}
{% set c = false %}

{# good! #}
{% case a || b || c %} {{ ast }} -> Case([a,b,c], {{ ast }})

{# oops! #}
{% case a || b || c %} {{ ast }} -> {% case (a || b || c) %}{{ast}} -> Case([b], {{ast}})

If this kind of reducing never happen, I'm ok, but I've not read all current parser yet, so I can't judge.

from jingoo.

What happens here is that it is parsed as:

{% case a || b || c %} {{ ast }} -> {% case (a || b || c) %}{{ast}}

But parsed output is processed (in the parser):

    let rec extract = function
      | OrOpExpr (e1, e2) -> extract e1 @ extract e2
      | e -> [e] in
    SwitchStatement ( e
                    , List.fold_right
                        (fun (a, b) acc -> ([a], b) :: acc) (cases)
                        (match default with None -> [] | Some stmts -> [ ([], stmts) ]))

from jingoo.

Thanks for reply. OrOpExpr is not evaluated before building SwitchStatement, and always generates list by extract, then I'm OK.

EDIT: In this argument, I totally forgot about that expr isn't evaluated before statement is evaluated...

from jingoo.

Apparently {% case "a" case "b" %} is hard to type, I agree with you.

Edit: I miss pushed the close issue button... but if more points are remain, re-open please.

from jingoo.