├── .gitignore ├── LICENSE ├── README.md ├── SYNTAX.md ├── THEOREMS.md ├── TODO.md ├── bin ├── bootstrap.js ├── hs │ ├── CHANGELOG.md │ ├── Formality.cabal │ ├── LICENSE │ ├── README.md │ └── src │ │ ├── Formality.hs │ │ ├── FormalityInternal.hs │ │ ├── Main.hs │ │ └── Setup.hs ├── js │ ├── package-lock.json │ ├── package.json │ └── src │ │ ├── cache.js │ │ ├── formality.js │ │ └── main.js ├── package-lock.json └── package.json ├── blog ├── 0-goodbye-javascript.md └── img │ └── formality-banner-white.png ├── docs ├── 237db229f1e6a224797029452b2c75f0.png ├── 391.index.js ├── 391.index.js.map ├── 987.index.js ├── 987.index.js.map ├── README.md ├── index.html ├── index.js └── index.js.map ├── src ├── A.fm ├── App.fm ├── App │ ├── Action.fm │ ├── Event.fm │ └── Render.fm ├── Array.fm ├── Array │ ├── alloc.fm │ ├── extract_tie.fm │ ├── extract_tip.fm │ ├── get.fm │ ├── mut.fm │ └── set.fm ├── Bit.fm ├── Bit │ └── not.fm ├── Bits.fm ├── Bits │ ├── add.fm │ ├── chunks_of.fm │ ├── chunks_of │ │ └── go.fm │ ├── concat.fm │ ├── div.fm │ ├── eql.fm │ ├── from_string.fm │ ├── inc.fm │ ├── length.fm │ ├── length │ │ └── go.fm │ ├── mod.fm │ ├── mul.fm │ ├── mul │ │ └── go.fm │ ├── reverse.fm │ ├── reverse │ │ └── tco.fm │ ├── show.fm │ ├── slice.fm │ ├── sub.fm │ ├── sub │ │ └── go.fm │ ├── tail.fm │ ├── to_nat.fm │ ├── to_string.fm │ └── to_u32.fm ├── Bool.fm ├── Bool │ ├── IsFalse.fm │ ├── IsTrue.fm │ ├── and.fm │ ├── double_negation.fm │ ├── elim.fm │ ├── eql.fm │ ├── false_neq_true.fm │ ├── if.fm │ ├── not.fm │ ├── notf.fm │ ├── or.fm │ ├── show.fm │ └── true_neq_false.fm ├── Buffer32.fm ├── Buffer32 │ ├── alloc.fm │ ├── get.fm │ ├── parse_hex.fm │ └── set.fm ├── Char.fm ├── Char │ ├── dec_value.fm │ ├── eql.fm │ ├── hex_value16.fm │ ├── hex_value32.fm │ ├── is_hex.fm │ ├── new.fm │ ├── newline.fm │ ├── parse.fm │ └── parse │ │ └── type.fm ├── Cmp.fm ├── Cmp │ ├── as_eql.fm │ ├── as_gte.fm │ ├── as_gtn.fm │ ├── as_lte.fm │ └── as_ltn.fm ├── Col32.fm ├── Col32 │ └── new.fm ├── Debug │ └── log.fm ├── Either.fm ├── Either │ ├── bind.fm │ ├── functor.fm │ ├── map.fm │ └── monad.fm ├── Empty.fm ├── Empty │ └── absurd.fm ├── Equal.fm ├── Equal │ ├── apply.fm │ ├── cast.fm │ ├── chain.fm │ ├── left.fm │ ├── mirror.fm │ ├── rewrite.fm │ └── right.fm ├── Example │ ├── IsEven │ │ ├── A.fm │ │ └── B.fm │ ├── Nat.fm │ ├── Suit.fm │ ├── black_friday_theorem.fm │ ├── double.fm │ ├── greet.fm │ ├── half.fm │ ├── hello_world.fm │ ├── open_and_let.fm │ ├── suit_to_string.fm │ ├── sum.fm │ ├── theorem.fm │ └── two_is_even │ │ ├── A.fm │ │ └── B.fm ├── F64.fm ├── F64 │ ├── 0.fm │ ├── 1.fm │ ├── 180.fm │ ├── 2.fm │ ├── 256.fm │ ├── Boundary.fm │ ├── Circle.fm │ ├── Line.fm │ ├── Ordering.fm │ ├── Segment.fm │ ├── V3.fm │ ├── V3 │ │ ├── add.fm │ │ ├── circle_boundary_intersects.fm │ │ ├── dist.fm │ │ ├── dot.fm │ │ ├── eql.fm │ │ ├── get_x.fm │ │ ├── get_y.fm │ │ ├── get_z.fm │ │ ├── len.fm │ │ ├── look_at.fm │ │ ├── ltn.fm │ │ ├── map.fm │ │ ├── map_x.fm │ │ ├── map_y.fm │ │ ├── map_z.fm │ │ ├── mul.fm │ │ ├── norm.fm │ │ ├── point_segment_dist.fm │ │ ├── point_segment_sqrdist.fm │ │ ├── polygon_to_segments.fm │ │ ├── polygon_to_segments │ │ │ ├── cons.fm │ │ │ ├── nil.fm │ │ │ └── transform.fm │ │ ├── rot_90.fm │ │ ├── rotate.fm │ │ ├── scale.fm │ │ ├── sqr_dist.fm │ │ ├── sub.fm │ │ └── to_pos32.fm │ ├── _1.fm │ ├── acos.fm │ ├── add.fm │ ├── asin.fm │ ├── atan.fm │ ├── cmp.fm │ ├── compare_numbers.fm │ ├── cos.fm │ ├── div.fm │ ├── eql.fm │ ├── exp.fm │ ├── floor.fm │ ├── from_bool.fm │ ├── gte.fm │ ├── gtn.fm │ ├── if.fm │ ├── is_between.fm │ ├── log.fm │ ├── lte.fm │ ├── ltn.fm │ ├── max.fm │ ├── min.fm │ ├── mod.fm │ ├── mul.fm │ ├── parse.fm │ ├── parse_binary.fm │ ├── pi.fm │ ├── pow.fm │ ├── rotate2d.fm │ ├── sin.fm │ ├── sqrt.fm │ ├── sub.fm │ ├── tan.fm │ └── to_u32.fm ├── Fm.fm ├── Fm │ ├── Binder.fm │ ├── Check.fm │ ├── Check │ │ ├── bind.fm │ │ ├── monad.fm │ │ ├── none.fm │ │ ├── pure.fm │ │ └── value.fm │ ├── Comp.fm │ ├── Constructor.fm │ ├── Constructor │ │ ├── build_term.fm │ │ ├── build_term │ │ │ ├── go.fm │ │ │ ├── opt.fm │ │ │ └── opt │ │ │ │ └── go.fm │ │ ├── build_type.fm │ │ └── build_type │ │ │ └── go.fm │ ├── Context.fm │ ├── Context │ │ ├── find.fm │ │ ├── find │ │ │ └── go.fm │ │ ├── get_name_skips.fm │ │ ├── names.fm │ │ └── show.fm │ ├── Core │ │ ├── read.fm │ │ ├── show.fm │ │ └── var_name.fm │ ├── Datatype.fm │ ├── Datatype │ │ ├── build_term.fm │ │ ├── build_term │ │ │ ├── constructor.fm │ │ │ ├── constructor │ │ │ ├── constructors.fm │ │ │ ├── constructors │ │ │ │ └── go.fm │ │ │ ├── go.fm │ │ │ ├── motive.fm │ │ │ └── motive │ │ │ │ └── go.fm │ │ ├── build_type.fm │ │ └── build_type │ │ │ └── go.fm │ ├── Def.fm │ ├── Defs.fm │ ├── Defs │ │ ├── core.fm │ │ ├── read.fm │ │ ├── report.fm │ │ └── show.fm │ ├── Error.fm │ ├── Error │ │ ├── origin.fm │ │ ├── relevant.fm │ │ └── show.fm │ ├── Letter.fm │ ├── MPath.fm │ ├── MPath │ │ ├── i.fm │ │ ├── nil.fm │ │ ├── o.fm │ │ └── to_bits.fm │ ├── Name.fm │ ├── Name │ │ ├── eql.fm │ │ ├── from_bits.fm │ │ ├── is_letter.fm │ │ ├── read.fm │ │ ├── show.fm │ │ └── to_bits.fm │ ├── Parser │ │ ├── add.fm │ │ ├── annotation.fm │ │ ├── application.fm │ │ ├── application │ │ │ ├── erased.fm │ │ │ └── hole.fm │ │ ├── apply.fm │ │ ├── arrow.fm │ │ ├── binder.fm │ │ ├── binder │ │ │ └── homo.fm │ │ ├── case.fm │ │ ├── case │ │ │ ├── case.fm │ │ │ └── with.fm │ │ ├── char.fm │ │ ├── char │ │ │ └── single.fm │ │ ├── concat.fm │ │ ├── cons.fm │ │ ├── constructor.fm │ │ ├── datatype.fm │ │ ├── def.fm │ │ ├── div.fm │ │ ├── do.fm │ │ ├── do │ │ │ └── statements.fm │ │ ├── equality.fm │ │ ├── file.fm │ │ ├── file │ │ │ ├── adt.fm │ │ │ ├── def.fm │ │ │ └── end.fm │ │ ├── forall.fm │ │ ├── forin.fm │ │ ├── forin │ │ │ └── 2.fm │ │ ├── forrange │ │ │ ├── u32.fm │ │ │ └── u32 │ │ │ │ └── 2.fm │ │ ├── get.fm │ │ ├── goal.fm │ │ ├── hole.fm │ │ ├── if.fm │ │ ├── inequality.fm │ │ ├── init.fm │ │ ├── item.fm │ │ ├── lambda.fm │ │ ├── lambda │ │ │ ├── erased.fm │ │ │ └── nameless.fm │ │ ├── let.fm │ │ ├── letforin.fm │ │ ├── letforrange │ │ │ └── u32.fm │ │ ├── letter.fm │ │ ├── list.fm │ │ ├── log.fm │ │ ├── make_forall.fm │ │ ├── make_lambda.fm │ │ ├── mirror.fm │ │ ├── mod.fm │ │ ├── mul.fm │ │ ├── name.fm │ │ ├── name1.fm │ │ ├── name_term.fm │ │ ├── nat.fm │ │ ├── op.fm │ │ ├── open.fm │ │ ├── pair.fm │ │ ├── parenthesis.fm │ │ ├── reference.fm │ │ ├── rewrite.fm │ │ ├── sigma.fm │ │ ├── sigma │ │ │ └── type.fm │ │ ├── some.fm │ │ ├── spaces.fm │ │ ├── stop.fm │ │ ├── string.fm │ │ ├── string_concat.fm │ │ ├── sub.fm │ │ ├── suffix.fm │ │ ├── term.fm │ │ ├── text.fm │ │ ├── type.fm │ │ ├── u16.fm │ │ ├── u32.fm │ │ ├── u64.fm │ │ └── u8.fm │ ├── Path.fm │ ├── Path │ │ ├── i.fm │ │ ├── nil.fm │ │ ├── o.fm │ │ └── to_bits.fm │ ├── Prim.fm │ ├── SmartMotive │ │ ├── make.fm │ │ ├── nams.fm │ │ ├── nams │ │ │ └── cont.fm │ │ ├── replace.fm │ │ ├── vals.fm │ │ └── vals │ │ │ └── cont.fm │ ├── Status.fm │ ├── Synth │ │ ├── file.fm │ │ ├── files_of.fm │ │ ├── files_of │ │ │ └── make.fm │ │ ├── fix.fm │ │ ├── load.fm │ │ ├── load │ │ │ └── go.fm │ │ ├── many.fm │ │ └── one.fm │ ├── Term.fm │ ├── Term │ │ ├── bind.fm │ │ ├── check.fm │ │ ├── desugar_cse.fm │ │ ├── desugar_cse │ │ │ ├── argument.fm │ │ │ ├── cases.fm │ │ │ └── motive.fm │ │ ├── equal.fm │ │ ├── equal │ │ │ ├── extra_holes.fm │ │ │ └── hole.fm │ │ ├── expand.fm │ │ ├── expand_at.fm │ │ ├── expand_ct.fm │ │ ├── has_holes.fm │ │ ├── identical.fm │ │ ├── inline.fm │ │ ├── inline │ │ │ ├── names.fm │ │ │ └── reduce.fm │ │ ├── normalize.fm │ │ ├── patch_at.fm │ │ ├── read.fm │ │ ├── reduce.fm │ │ ├── serialize.fm │ │ ├── serialize │ │ │ └── name.fm │ │ ├── show.fm │ │ ├── show │ │ │ ├── app.fm │ │ │ ├── app │ │ │ │ └── done.fm │ │ │ ├── as_nat.fm │ │ │ ├── as_nat │ │ │ │ └── go.fm │ │ │ ├── go.fm │ │ │ └── is_ref.fm │ │ ├── unroll_chr.fm │ │ ├── unroll_chr │ │ │ └── bits.fm │ │ ├── unroll_nat.fm │ │ └── unroll_str.fm │ ├── backslash.fm │ ├── checker │ │ ├── code.fm │ │ └── io │ │ │ ├── file.fm │ │ │ └── one.fm │ ├── color.fm │ ├── define.fm │ ├── escape.fm │ ├── escape │ │ └── char.fm │ ├── escapes.fm │ ├── files.fm │ ├── get.fm │ ├── go.fm │ ├── highlight.fm │ ├── highlight │ │ ├── end.fm │ │ └── tc.fm │ ├── mut.fm │ ├── set.fm │ └── to_core │ │ └── io │ │ └── one.fm ├── Function.fm ├── Function │ ├── call.fm │ ├── comp.fm │ ├── const.fm │ ├── curry.fm │ ├── dcomp.fm │ ├── flip.fm │ ├── id.fm │ ├── pipe.fm │ └── uncurry.fm ├── Functor.fm ├── Functor │ ├── const.fm │ └── map.fm ├── GMap.fm ├── GMap │ ├── adjust.fm │ ├── adjust_with_key.fm │ ├── balance.fm │ ├── concat3.fm │ ├── delete_min.fm │ ├── foldr.fm │ ├── foldr │ │ └── go.fm │ ├── foldr_with_key.fm │ ├── foldr_with_key │ │ └── go.fm │ ├── from_list.fm │ ├── from_list │ │ └── go.fm │ ├── insert.fm │ ├── is_balanced.fm │ ├── lookup.fm │ ├── lookup_with_default.fm │ ├── map.fm │ ├── member.fm │ ├── min.fm │ ├── node.fm │ ├── not_member.fm │ ├── null.fm │ ├── show.fm │ ├── singleton.fm │ ├── size.fm │ ├── split_gtn.fm │ ├── split_ltn.fm │ ├── tests │ │ └── 1.fm │ ├── to_list.fm │ ├── union.fm │ └── w.fm ├── GSet.fm ├── GSet │ ├── balance.fm │ ├── concat3.fm │ ├── delete_min.fm │ ├── foldr.fm │ ├── foldr │ │ └── go.fm │ ├── from_list.fm │ ├── insert.fm │ ├── is_balanced.fm │ ├── is_singleton.fm │ ├── map.fm │ ├── member.fm │ ├── members.fm │ ├── min.fm │ ├── node.fm │ ├── not_member.fm │ ├── null.fm │ ├── show.fm │ ├── singleton.fm │ ├── size.fm │ ├── split_gtn.fm │ ├── split_ltn.fm │ ├── to_list.fm │ ├── union.fm │ └── w.fm ├── IO.fm ├── IO │ ├── bind.fm │ ├── exit.fm │ ├── get_args.fm │ ├── get_file.fm │ ├── get_line.fm │ ├── monad.fm │ ├── print.fm │ ├── prompt.fm │ ├── purify.fm │ ├── put_string.fm │ └── set_file.fm ├── Image3D.fm ├── Image3D │ ├── Draw │ │ └── square.fm │ ├── alloc_capacity.fm │ ├── clear.fm │ ├── empty.fm │ ├── get_capacity.fm │ ├── get_col.fm │ ├── get_length.fm │ ├── parse.fm │ ├── parse_byte.fm │ ├── push.fm │ ├── set.fm │ ├── set_col.fm │ ├── set_length.fm │ └── set_pos.fm ├── Int.fm ├── Int │ ├── 0.fm │ ├── 1.fm │ ├── add.fm │ ├── cmp.fm │ ├── div_nat.fm │ ├── eql.fm │ ├── from_nat.fm │ ├── mod_nat.fm │ ├── mul.fm │ ├── neg.fm │ ├── new.fm │ ├── sub.fm │ ├── to_nat.fm │ └── to_string_base.fm ├── JSON.fm ├── Lex.fm ├── List.fm ├── List │ ├── Builder.fm │ ├── Builder │ │ ├── concat.fm │ │ ├── cons.fm │ │ ├── new.fm │ │ └── snoc.fm │ ├── all.fm │ ├── and.fm │ ├── any.fm │ ├── append.fm │ ├── at.fm │ ├── at_last.fm │ ├── bind.fm │ ├── chunk.fm │ ├── chunks_of.fm │ ├── chunks_of │ │ └── go.fm │ ├── commute_cons_map.fm │ ├── concat.fm │ ├── delete_at.fm │ ├── delete_by.fm │ ├── drop.fm │ ├── drop_while.fm │ ├── elem.fm │ ├── eql.fm │ ├── filter.fm │ ├── find.fm │ ├── find_last.fm │ ├── find_last │ │ └── go.fm │ ├── flatten.fm │ ├── fold.fm │ ├── fold_zip.fm │ ├── foldr.fm │ ├── for.fm │ ├── head.fm │ ├── head_with_default.fm │ ├── ifind.fm │ ├── ifind │ │ └── go.fm │ ├── imap.fm │ ├── indices.fm │ ├── indices │ │ └── u32.fm │ ├── init.fm │ ├── insert_sort_nat.fm │ ├── insert_sort_nat │ │ └── aux.fm │ ├── intercalate.fm │ ├── intersperse.fm │ ├── is_empty.fm │ ├── length.fm │ ├── map.fm │ ├── mapped.fm │ ├── monad.fm │ ├── null.fm │ ├── or.fm │ ├── product.fm │ ├── product │ │ └── go.fm │ ├── pure.fm │ ├── range.fm │ ├── range │ │ ├── go.fm │ │ ├── nat.fm │ │ └── nat │ │ │ └── go.fm │ ├── reverse.fm │ ├── reverse │ │ └── go.fm │ ├── run_builder.fm │ ├── show.fm │ ├── span.fm │ ├── sum.fm │ ├── sum │ │ └── go.fm │ ├── tail.fm │ ├── take.fm │ ├── take_while.fm │ ├── to_builder.fm │ ├── to_builder │ │ └── go.fm │ ├── uncons.fm │ ├── unfoldr.fm │ ├── unfoldr │ │ └── go.fm │ ├── update_at.fm │ ├── zip.fm │ └── zip_with.fm ├── Main.fm ├── Map.fm ├── Map │ ├── Row.fm │ ├── delete.fm │ ├── disj.fm │ ├── fold.fm │ ├── from_list.fm │ ├── get.fm │ ├── keys.fm │ ├── keys │ │ └── go.fm │ ├── map.fm │ ├── merge.fm │ ├── merge │ │ └── go.fm │ ├── mut.fm │ ├── query.fm │ ├── set.fm │ ├── to_list.fm │ ├── to_list │ │ └── go.fm │ ├── union.fm │ ├── values.fm │ └── values │ │ └── go.fm ├── Maybe.fm ├── Maybe │ ├── IsSome.fm │ ├── bind.fm │ ├── default.fm │ ├── extract.fm │ ├── functor.fm │ ├── join.fm │ ├── map.fm │ ├── mapped.fm │ ├── monad.fm │ ├── or.fm │ ├── pure.fm │ └── to_bool.fm ├── Monad.fm ├── Monad │ ├── bind.fm │ └── pure.fm ├── Mons │ ├── Action.fm │ ├── Attr.fm │ ├── Attr │ │ ├── new_hero.fm │ │ ├── new_mage.fm │ │ └── new_neutral.fm │ ├── Dir.fm │ ├── Dir │ │ └── move.fm │ ├── Effect.fm │ ├── Effect │ │ └── clear.fm │ ├── Game.fm │ ├── Game │ │ ├── get_hero_pos.fm │ │ ├── get_skills_at.fm │ │ ├── get_tile.fm │ │ ├── get_user_pos.fm │ │ ├── get_usr.fm │ │ ├── set_map.fm │ │ ├── set_stt.fm │ │ ├── set_tik.fm │ │ ├── set_user_pos.fm │ │ ├── set_usr.fm │ │ ├── update.fm │ │ └── update_obj.fm │ ├── Kind.fm │ ├── Kind │ │ ├── attr.fm │ │ ├── const.fm │ │ ├── get_agi.fm │ │ ├── get_skills.fm │ │ ├── inter.fm │ │ ├── is_hero.fm │ │ ├── mons.fm │ │ ├── new_const.fm │ │ ├── new_mon.fm │ │ ├── new_mons.fm │ │ ├── new_terrain.fm │ │ ├── set_default_battle_spr.fm │ │ ├── set_pic.fm │ │ ├── set_static_sprites.fm │ │ └── terrain.fm │ ├── Map.fm │ ├── Map │ │ ├── Dir.fm │ │ ├── Dir │ │ │ └── expanded.fm │ │ ├── code_to_tile │ │ │ └── aux.fm │ │ ├── del.fm │ │ ├── get.fm │ │ ├── get_hero.fm │ │ ├── get_list.fm │ │ ├── get_top.fm │ │ ├── new.fm │ │ ├── pop.fm │ │ ├── push.fm │ │ ├── set.fm │ │ └── set_list.fm │ ├── Object.fm │ ├── Object │ │ ├── add_defeated_mon.fm │ │ ├── capture_boss.fm │ │ ├── delete_from_bag.fm │ │ ├── get_adjacent_pos.fm │ │ ├── get_ani.fm │ │ ├── get_current_mon.fm │ │ ├── get_dir.fm │ │ ├── get_dmg.fm │ │ ├── get_kin.fm │ │ ├── get_pad.fm │ │ ├── heal.fm │ │ ├── hero.fm │ │ ├── hit.fm │ │ ├── is_bag_full.fm │ │ ├── is_free_to_move.fm │ │ ├── is_full_bag.fm │ │ ├── is_standing.fm │ │ ├── is_walking.fm │ │ ├── new_of_kind.fm │ │ ├── pop_from_bag.fm │ │ ├── push_to_bag.fm │ │ ├── qtd_mons_defeated.fm │ │ ├── set_ani.fm │ │ ├── set_bag.fm │ │ ├── set_bos.fm │ │ ├── set_cap.fm │ │ ├── set_dir.fm │ │ ├── set_dmg.fm │ │ ├── set_idl.fm │ │ ├── set_kin.fm │ │ ├── set_mon.fm │ │ ├── set_pad.fm │ │ ├── set_pad_d.fm │ │ ├── set_pad_l.fm │ │ ├── set_pad_r.fm │ │ ├── set_pad_u.fm │ │ ├── update_interactive.fm │ │ └── void.fm │ ├── Pad.fm │ ├── Pad │ │ ├── null.fm │ │ ├── set_d.fm │ │ ├── set_l.fm │ │ ├── set_r.fm │ │ └── set_u.fm │ ├── Screen.fm │ ├── Skill.fm │ ├── Sprite.fm │ ├── Turn.fm │ ├── Turn │ │ ├── empty.fm │ │ ├── hero_run.fm │ │ ├── hero_turn.fm │ │ ├── is_active.fm │ │ └── is_last_player_move.fm │ ├── Type.fm │ ├── global_scr_mid.fm │ ├── image_to_global.fm │ ├── scr_h.fm │ ├── scr_mid.fm │ ├── scr_w.fm │ ├── vox_mid.fm │ └── walk_char_pack.fm ├── Nat.fm ├── Nat │ ├── add.fm │ ├── add │ │ ├── assoc.fm │ │ ├── cancel_left.fm │ │ ├── comm.fm │ │ ├── succ_left.fm │ │ ├── succ_right.fm │ │ ├── zero_left.fm │ │ └── zero_right.fm │ ├── apply.fm │ ├── bitwise_and.fm │ ├── cmp.fm │ ├── div.fm │ ├── div_mod.fm │ ├── div_mod │ │ └── go.fm │ ├── divides.fm │ ├── double.fm │ ├── eql.fm │ ├── for.fm │ ├── from_base.fm │ ├── from_base │ │ └── go.fm │ ├── gcd.fm │ ├── gcd │ │ ├── self.fm │ │ ├── succ.fm │ │ ├── zero_left.fm │ │ └── zero_right.fm │ ├── gte.fm │ ├── gtn.fm │ ├── half.fm │ ├── induction.fm │ ├── is_even.fm │ ├── is_zero.fm │ ├── lcm.fm │ ├── lte.fm │ ├── ltn.fm │ ├── min.fm │ ├── mod.fm │ ├── mod │ │ ├── go.fm │ │ ├── go_mod_one_equals_zero.fm │ │ ├── go_self.fm │ │ ├── mod_one_equals_zero.fm │ │ ├── self.fm │ │ └── zero_mod_equals_zero.fm │ ├── mul.fm │ ├── mul │ │ ├── comm.fm │ │ ├── one_left.fm │ │ ├── one_right.fm │ │ ├── zero_left.fm │ │ └── zero_right.fm │ ├── odd.fm │ ├── one_neq_zero.fm │ ├── pred.fm │ ├── same.fm │ ├── show.fm │ ├── show_digit.fm │ ├── square.fm │ ├── sub.fm │ ├── sub_rem.fm │ ├── succ_inj.fm │ ├── succ_neq_zero.fm │ ├── sum.fm │ ├── sum │ │ └── go.fm │ ├── to_base.fm │ ├── to_base │ │ └── go.fm │ ├── to_bits.fm │ ├── to_f64.fm │ ├── to_string.fm │ ├── to_string_base.fm │ ├── to_string_unary.fm │ ├── to_u16.fm │ ├── to_u32.fm │ ├── to_u64.fm │ └── to_u8.fm ├── Not.fm ├── Pair.fm ├── Pair │ ├── fst.fm │ ├── functor.fm │ ├── map.fm │ ├── show.fm │ └── snd.fm ├── Parser.fm ├── Parser │ ├── ErrorAt.fm │ ├── ErrorAt │ │ └── combine.fm │ ├── Reply.fm │ ├── bind.fm │ ├── char_if.fm │ ├── consume.fm │ ├── digit.fm │ ├── eof.fm │ ├── fail.fm │ ├── first_of.fm │ ├── first_of │ │ └── go.fm │ ├── get_code.fm │ ├── get_index.fm │ ├── if_not.fm │ ├── is_eof.fm │ ├── log.fm │ ├── log_code.fm │ ├── many.fm │ ├── many │ │ └── go.fm │ ├── many1.fm │ ├── maybe.fm │ ├── monad.fm │ ├── nat.fm │ ├── one.fm │ ├── pure.fm │ ├── run.fm │ ├── set_index.fm │ ├── spaces.fm │ ├── spaces_text.fm │ ├── text.fm │ ├── text │ │ └── go.fm │ ├── until.fm │ ├── until │ │ └── go.fm │ └── until1.fm ├── Pos32.fm ├── Pos32 │ └── new.fm ├── Provit │ └── 0.fm ├── Queue.fm ├── Queue │ ├── balance.fm │ ├── cons.fm │ ├── empty.fm │ ├── foldr.fm │ ├── from_list.fm │ ├── head.fm │ ├── init.fm │ ├── last.fm │ ├── length.fm │ ├── map.fm │ ├── max_diff.fm │ ├── null.fm │ ├── snoc.fm │ ├── tail.fm │ └── to_list.fm ├── Set.fm ├── Set │ ├── del.fm │ ├── has.fm │ ├── mut │ │ ├── del.fm │ │ ├── has.fm │ │ ├── new.fm │ │ └── set.fm │ ├── new.fm │ └── set.fm ├── Sigma.fm ├── Sigma │ ├── fst.fm │ └── snd.fm ├── String.fm ├── String │ ├── Builder.fm │ ├── Builder │ │ ├── concat.fm │ │ ├── new.fm │ │ └── snoc.fm │ ├── append.fm │ ├── concat.fm │ ├── drop.fm │ ├── ends_with.fm │ ├── eql.fm │ ├── filter.fm │ ├── flatten.fm │ ├── flatten │ │ └── go.fm │ ├── fold.fm │ ├── from_list.fm │ ├── head.fm │ ├── imap.fm │ ├── includes.fm │ ├── includes │ │ └── go.fm │ ├── intercalate.fm │ ├── intersperse.fm │ ├── is_empty.fm │ ├── join.fm │ ├── join │ │ └── go.fm │ ├── length.fm │ ├── length │ │ └── go.fm │ ├── length32.fm │ ├── length32 │ │ └── go.fm │ ├── map.fm │ ├── not_empty.fm │ ├── null.fm │ ├── pad_left.fm │ ├── pad_right.fm │ ├── pure.fm │ ├── remove_start_with.fm │ ├── remove_start_with │ │ └── go.fm │ ├── repeat.fm │ ├── reverse.fm │ ├── reverse │ │ └── go.fm │ ├── run_builder.fm │ ├── show.fm │ ├── slice.fm │ ├── span.fm │ ├── split.fm │ ├── split │ │ └── go.fm │ ├── starts_with.fm │ ├── take.fm │ ├── to_bits.fm │ ├── to_builder.fm │ ├── to_builder │ │ └── go.fm │ └── to_list.fm ├── Test.fm ├── The.fm ├── U16.fm ├── U16 │ ├── add.fm │ ├── and.fm │ ├── btw.fm │ ├── concat.fm │ ├── div.fm │ ├── eql.fm │ ├── gte.fm │ ├── gtn.fm │ ├── inc.fm │ ├── lte.fm │ ├── ltn.fm │ ├── mod.fm │ ├── mul.fm │ ├── or.fm │ ├── pow.fm │ ├── shl.fm │ ├── show_hex.fm │ ├── shr.fm │ ├── sub.fm │ ├── to_bits.fm │ ├── to_u32.fm │ ├── to_word.fm │ ├── xor.fm │ └── zero.fm ├── U256.fm ├── U256 │ └── 0.fm ├── U32.fm ├── U32 │ ├── add.fm │ ├── and.fm │ ├── div.fm │ ├── eql.fm │ ├── for.fm │ ├── gte.fm │ ├── gtn.fm │ ├── inc.fm │ ├── length.fm │ ├── lte.fm │ ├── ltn.fm │ ├── mod.fm │ ├── mul.fm │ ├── needed_depth.fm │ ├── needed_depth │ │ └── go.fm │ ├── or.fm │ ├── pow.fm │ ├── read_base.fm │ ├── shl.fm │ ├── shr.fm │ ├── slice.fm │ ├── sub.fm │ ├── to_bits.fm │ ├── to_f64.fm │ ├── to_nat.fm │ ├── to_string.fm │ ├── xor.fm │ └── zero.fm ├── U64.fm ├── U64 │ ├── add.fm │ ├── and.fm │ ├── div.fm │ ├── eql.fm │ ├── gte.fm │ ├── gtn.fm │ ├── inc.fm │ ├── lte.fm │ ├── ltn.fm │ ├── mod.fm │ ├── mul.fm │ ├── or.fm │ ├── pow.fm │ ├── shl.fm │ ├── shr.fm │ ├── sub.fm │ ├── to_bits.fm │ ├── xor.fm │ └── zero.fm ├── U8.fm ├── U8 │ ├── add.fm │ ├── and.fm │ ├── concat.fm │ ├── div.fm │ ├── eql.fm │ ├── gte.fm │ ├── gtn.fm │ ├── inc.fm │ ├── lte.fm │ ├── ltn.fm │ ├── mod.fm │ ├── mul.fm │ ├── or.fm │ ├── pow.fm │ ├── shl.fm │ ├── shr.fm │ ├── sub.fm │ ├── to_bits.fm │ ├── xor.fm │ └── zero.fm ├── Unit.fm ├── Unit │ └── show.fm ├── Vector.fm ├── Vector │ ├── from_list.fm │ ├── head.fm │ ├── main.fm │ └── tail.fm ├── Web │ └── Demo.fm ├── Word.fm └── Word │ ├── add.fm │ ├── adder.fm │ ├── and.fm │ ├── btw.fm │ ├── cmp.fm │ ├── cmp │ └── go.fm │ ├── concat.fm │ ├── div.fm │ ├── drop.fm │ ├── eql.fm │ ├── fold.fm │ ├── foldl.fm │ ├── from_bits.fm │ ├── gte.fm │ ├── gtn.fm │ ├── inc.fm │ ├── lte.fm │ ├── ltn.fm │ ├── mod.fm │ ├── mul.fm │ ├── nat_log2.fm │ ├── nat_log2 │ └── go.fm │ ├── neg.fm │ ├── neg │ └── aux.fm │ ├── or.fm │ ├── pow.fm │ ├── pred.fm │ ├── reverse.fm │ ├── shift_left.fm │ ├── shift_right.fm │ ├── sub.fm │ ├── subber.fm │ ├── to_bits.fm │ ├── to_nat.fm │ ├── trim.fm │ ├── xor.fm │ └── zero.fm └── web ├── build.js ├── package-lock.json ├── package.json ├── server.js ├── src ├── AppList.js ├── AppPlay.js ├── apps │ ├── Moonad.Demo.js │ ├── Web.Demo.js │ └── index.js ├── assets │ ├── favicon.ico │ ├── moonad_logo.png │ └── moonad_logo_white.png ├── index.html └── index.js └── webpack.config.js /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | .DS_Store 3 | bin/node_modules/ 4 | src/_* 5 | src/tmp* 6 | bin/hs/cabal.project.local* 7 | web/node_modules/ 8 | -------------------------------------------------------------------------------- /bin/hs/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Revision history for Formality 2 | 3 | ## 0.1.0.0 -- YYYY-mm-dd 4 | 5 | * First version. Released on an unsuspecting world. 6 | -------------------------------------------------------------------------------- /bin/hs/src/Setup.hs: -------------------------------------------------------------------------------- 1 | import Distribution.Simple 2 | main = defaultMain 3 | -------------------------------------------------------------------------------- /blog/img/formality-banner-white.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moonad/Formality-tmp/8ef7d8ef9c70d51e295c4b11e36c0882d6bfde75/blog/img/formality-banner-white.png -------------------------------------------------------------------------------- /docs/237db229f1e6a224797029452b2c75f0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moonad/Formality-tmp/8ef7d8ef9c70d51e295c4b11e36c0882d6bfde75/docs/237db229f1e6a224797029452b2c75f0.png -------------------------------------------------------------------------------- /docs/README.md: -------------------------------------------------------------------------------- 1 | This is not Formality's documentation, but its web app! Access it at 2 | [https://moonad.github.io/Formality/](https://moonad.github.io/Formality/). 3 | -------------------------------------------------------------------------------- /src/A.fm: -------------------------------------------------------------------------------- 1 | A: App(Unit) 2 | App.new!(unit, (state) App.Render.txt("ok"), (e,s) []) 3 | -------------------------------------------------------------------------------- /src/App.fm: -------------------------------------------------------------------------------- 1 | type App { 2 | new( 3 | init: S, 4 | draw: S -> App.Render, 5 | when: App.Event -> S -> List(App.Action(S)) 6 | ) 7 | } 8 | -------------------------------------------------------------------------------- /src/App/Action.fm: -------------------------------------------------------------------------------- 1 | type App.Action { 2 | state(value: S) 3 | resize(width: U32, height: U32) 4 | print(text: String) 5 | post(room: Word(48), data: Word(256)) 6 | watch(room: Word(48)) 7 | } 8 | -------------------------------------------------------------------------------- /src/App/Render.fm: -------------------------------------------------------------------------------- 1 | type App.Render { 2 | txt(text: String) 3 | pix(pixs: Image3D) 4 | } 5 | -------------------------------------------------------------------------------- /src/Array.fm: -------------------------------------------------------------------------------- 1 | type Array ~ (depth: Nat) { 2 | tip(value: A) ~ (depth: Nat.zero), 3 | tie(lft: Array(A,depth), rgt: Array(A,depth)) ~ (depth: Nat.succ(depth)) 4 | } -------------------------------------------------------------------------------- /src/Array/alloc.fm: -------------------------------------------------------------------------------- 1 | Array.alloc(depth: Nat, x: A): Array(A, depth) 2 | case depth { 3 | zero: Array.tip(x), 4 | succ: 5 | let half = Array.alloc(depth.pred, x) 6 | Array.tie(half, half) 7 | } : Array(A, depth) -------------------------------------------------------------------------------- /src/Array/extract_tip.fm: -------------------------------------------------------------------------------- 1 | Array.extract_tip(arr: Array(A,0)): A 2 | case arr { 3 | tip: arr.value, 4 | tie: Unit.new 5 | } : case arr.depth { 6 | zero: A, 7 | succ: Unit 8 | } 9 | -------------------------------------------------------------------------------- /src/Array/set.fm: -------------------------------------------------------------------------------- 1 | Array.set(idx: Word(depth), val: A, arr: Array(A,depth)) 2 | : Array(A,depth) 3 | Array.mut(idx, (x) val, arr) 4 | -------------------------------------------------------------------------------- /src/Bit.fm: -------------------------------------------------------------------------------- 1 | type Bit { 2 | o, 3 | i, 4 | } -------------------------------------------------------------------------------- /src/Bit/not.fm: -------------------------------------------------------------------------------- 1 | Bit.not(b: Bit): Bit 2 | case b { 3 | o: Bit.i, 4 | i: Bit.o, 5 | } -------------------------------------------------------------------------------- /src/Bits.fm: -------------------------------------------------------------------------------- 1 | type Bits { 2 | e, 3 | o(pred: Bits), 4 | i(pred: Bits), 5 | } 6 | -------------------------------------------------------------------------------- /src/Bits/chunks_of.fm: -------------------------------------------------------------------------------- 1 | Bits.chunks_of(len: Nat, bits: Bits): List(Bits) 2 | Bits.chunks_of.go(len, bits, len, Bits.e) -------------------------------------------------------------------------------- /src/Bits/concat.fm: -------------------------------------------------------------------------------- 1 | Bits.concat(a: Bits, b: Bits): Bits 2 | case a { 3 | e: b, 4 | o: Bits.o(Bits.concat(a.pred, b)), 5 | i: Bits.i(Bits.concat(a.pred, b)) 6 | } -------------------------------------------------------------------------------- /src/Bits/div.fm: -------------------------------------------------------------------------------- 1 | Bits.div(a: Bits, b: Bits): Bits 2 | Bits.div(a, b) -------------------------------------------------------------------------------- /src/Bits/inc.fm: -------------------------------------------------------------------------------- 1 | Bits.inc(a: Bits): Bits 2 | case a { 3 | e: Bits.i(Bits.e), 4 | o: Bits.i(a.pred), 5 | i: Bits.o(Bits.inc(a.pred)), 6 | } -------------------------------------------------------------------------------- /src/Bits/length.fm: -------------------------------------------------------------------------------- 1 | Bits.length(xs: Bits): Nat 2 | Bits.length.go(xs, 0) -------------------------------------------------------------------------------- /src/Bits/length/go.fm: -------------------------------------------------------------------------------- 1 | Bits.length.go(xs: Bits, n: Nat): Nat 2 | case xs { 3 | e: n, 4 | o : Bits.length.go(xs.pred, Nat.succ(n)), 5 | i : Bits.length.go(xs.pred, Nat.succ(n)) 6 | } -------------------------------------------------------------------------------- /src/Bits/mod.fm: -------------------------------------------------------------------------------- 1 | Bits.mod(a: Bits, b: Bits): Bits 2 | Bits.mod(a, b) -------------------------------------------------------------------------------- /src/Bits/mul.fm: -------------------------------------------------------------------------------- 1 | Bits.mul(a: Bits, b: Bits): Bits 2 | Bits.mul.go(a, b, Bits.e) -------------------------------------------------------------------------------- /src/Bits/mul/go.fm: -------------------------------------------------------------------------------- 1 | Bits.mul.go(a: Bits, b: Bits, bits: Bits): Bits 2 | case b { 3 | e: bits, 4 | o : Bits.mul.go(Bits.o(a), b.pred, bits), 5 | i : Bits.mul.go(Bits.o(a), b.pred, Bits.add(a, bits)) 6 | } -------------------------------------------------------------------------------- /src/Bits/reverse.fm: -------------------------------------------------------------------------------- 1 | Bits.reverse(a: Bits): Bits 2 | Bits.reverse.tco(a, Bits.e) -------------------------------------------------------------------------------- /src/Bits/reverse/tco.fm: -------------------------------------------------------------------------------- 1 | Bits.reverse.tco(a: Bits, r: Bits): Bits 2 | case a { 3 | e: r, 4 | o: Bits.reverse.tco(a.pred, Bits.o(r)), 5 | i: Bits.reverse.tco(a.pred, Bits.i(r)) 6 | } -------------------------------------------------------------------------------- /src/Bits/show.fm: -------------------------------------------------------------------------------- 1 | Bits.show(a: Bits): String 2 | case a { 3 | e: "", 4 | o: String.cons('0', Bits.show(a.pred)), 5 | i: String.cons('1', Bits.show(a.pred)), 6 | } -------------------------------------------------------------------------------- /src/Bits/slice.fm: -------------------------------------------------------------------------------- 1 | Bits.slice(len: Nat, bits: Bits): Bits 2 | case len { 3 | zero: Bits.e, 4 | succ: case bits { 5 | e: Bits.e, 6 | o : Bits.o(Bits.slice(len.pred, bits.pred)), 7 | i : Bits.i(Bits.slice(len.pred, bits.pred)) 8 | } 9 | } -------------------------------------------------------------------------------- /src/Bits/sub.fm: -------------------------------------------------------------------------------- 1 | Bits.sub(a: Bits, b: Bits): Bits 2 | Bits.reverse(Bits.sub.go(a, b, Bits.e)) -------------------------------------------------------------------------------- /src/Bits/tail.fm: -------------------------------------------------------------------------------- 1 | Bits.tail(a: Bits): Bits 2 | case a { 3 | e: Bits.e, 4 | o: a.pred, 5 | i: a.pred, 6 | } -------------------------------------------------------------------------------- /src/Bits/to_nat.fm: -------------------------------------------------------------------------------- 1 | Bits.to_nat(b: Bits): Nat 2 | case b { 3 | e: 0, 4 | o: Nat.mul(2, Bits.to_nat(b.pred)), 5 | i: Nat.succ(Nat.mul(2, Bits.to_nat(b.pred))) 6 | } -------------------------------------------------------------------------------- /src/Bits/to_string.fm: -------------------------------------------------------------------------------- 1 | Bits.to_string(bits: Bits): String 2 | case bits { 3 | e: "", 4 | o : String.concat("0", Bits.to_string(bits.pred)), 5 | i : String.concat("1", Bits.to_string(bits.pred)) 6 | } -------------------------------------------------------------------------------- /src/Bits/to_u32.fm: -------------------------------------------------------------------------------- 1 | Bits.to_u32(bits: Bits): U32 2 | U32.new(Word.from_bits(32, bits)) -------------------------------------------------------------------------------- /src/Bool.fm: -------------------------------------------------------------------------------- 1 | type Bool { 2 | true, 3 | false, 4 | } 5 | -------------------------------------------------------------------------------- /src/Bool/IsFalse.fm: -------------------------------------------------------------------------------- 1 | Bool.IsFalse(b: Bool): Type 2 | case b { 3 | true: Empty, 4 | false: Unit, 5 | } -------------------------------------------------------------------------------- /src/Bool/IsTrue.fm: -------------------------------------------------------------------------------- 1 | Bool.IsTrue(b: Bool): Type 2 | case b { 3 | true: Unit, 4 | false: Empty, 5 | } -------------------------------------------------------------------------------- /src/Bool/and.fm: -------------------------------------------------------------------------------- 1 | Bool.and(a: Bool, b: Bool): Bool 2 | case a { 3 | true: b, 4 | false: false, 5 | } -------------------------------------------------------------------------------- /src/Bool/double_negation.fm: -------------------------------------------------------------------------------- 1 | Bool.double_negation(b: Bool): Equal(Bool, Bool.not(Bool.not(b)), b) 2 | case b { 3 | true: Equal.refl<_, Bool.true>, 4 | false: Equal.refl<_, Bool.false>, 5 | } : Equal(Bool, Bool.not(Bool.not(b)), b) -------------------------------------------------------------------------------- /src/Bool/elim.fm: -------------------------------------------------------------------------------- 1 | Bool.elim(b: Bool): Type> -> P(Bool.true) -> P(Bool.false) -> P(b) 2 |

(t) (f) b

(t, f) -------------------------------------------------------------------------------- /src/Bool/eql.fm: -------------------------------------------------------------------------------- 1 | Bool.eql(a: Bool, b: Bool): Bool 2 | case a { 3 | true: b, 4 | false: Bool.not(b), 5 | } -------------------------------------------------------------------------------- /src/Bool/false_neq_true.fm: -------------------------------------------------------------------------------- 1 | Bool.false_neq_true: false != true 2 | (e) unit :: rewrite x in (if x then Empty else Unit) with e -------------------------------------------------------------------------------- /src/Bool/if.fm: -------------------------------------------------------------------------------- 1 | Bool.if(cond: Bool, true_case: A, false_case: A): A 2 | case cond{ 3 | true : true_case 4 | false: false_case 5 | } -------------------------------------------------------------------------------- /src/Bool/not.fm: -------------------------------------------------------------------------------- 1 | Bool.not(a: Bool): Bool 2 | case a { 3 | true: false, 4 | false: true, 5 | } -------------------------------------------------------------------------------- /src/Bool/notf.fm: -------------------------------------------------------------------------------- 1 | Bool.notf(a: Bool): Bool 2 |

(t, f) 3 | case a{ 4 | true: f, 5 | false: t, 6 | } : P(Bool.notf(a)) -------------------------------------------------------------------------------- /src/Bool/or.fm: -------------------------------------------------------------------------------- 1 | Bool.or(a: Bool, b: Bool): Bool 2 | case a { 3 | true: Bool.true, 4 | false: b, 5 | } -------------------------------------------------------------------------------- /src/Bool/show.fm: -------------------------------------------------------------------------------- 1 | Bool.show(b: Bool): String 2 | case b { 3 | true: "Bool.true", 4 | false: "Bool.false", 5 | } -------------------------------------------------------------------------------- /src/Bool/true_neq_false.fm: -------------------------------------------------------------------------------- 1 | Bool.true_neq_false: true != false 2 | (e) unit :: rewrite x in (if x then Unit else Empty) with e -------------------------------------------------------------------------------- /src/Buffer32.fm: -------------------------------------------------------------------------------- 1 | type Buffer32 { 2 | new(depth: Nat, array: Array(U32, depth)) 3 | } -------------------------------------------------------------------------------- /src/Buffer32/alloc.fm: -------------------------------------------------------------------------------- 1 | Buffer32.alloc(depth: Nat): Buffer32 2 | Buffer32.new(depth, Array.alloc(depth, U32.zero)) -------------------------------------------------------------------------------- /src/Buffer32/get.fm: -------------------------------------------------------------------------------- 1 | Buffer32.get(idx: U32, buf: Buffer32): U32 2 | let {dep,arr} = buf 3 | open idx 4 | let idx = Word.trim<32>(dep, idx.value) 5 | Array.get(idx, arr) 6 | -------------------------------------------------------------------------------- /src/Buffer32/parse_hex.fm: -------------------------------------------------------------------------------- 1 | Buffer32.parse_hex(hex: String): Buffer32 2 | Buffer32.parse_hex(hex) 3 | -------------------------------------------------------------------------------- /src/Buffer32/set.fm: -------------------------------------------------------------------------------- 1 | Buffer32.set(idx: U32, val: U32, buf: Buffer32): Buffer32 2 | let {dep,arr} = buf 3 | open idx 4 | let idx = Word.trim<32>(dep, idx.value) 5 | def arr = Array.set(idx, val, arr) 6 | Buffer32.new(dep, arr) 7 | -------------------------------------------------------------------------------- /src/Char.fm: -------------------------------------------------------------------------------- 1 | Char: Type 2 | U16 -------------------------------------------------------------------------------- /src/Char/eql.fm: -------------------------------------------------------------------------------- 1 | Char.eql(a: Char, b: Char): Bool 2 | U16.eql(a, b) -------------------------------------------------------------------------------- /src/Char/hex_value32.fm: -------------------------------------------------------------------------------- 1 | Char.hex_value32(chr: Char): U32 2 | U16.to_u32(Char.hex_value16(chr)) -------------------------------------------------------------------------------- /src/Char/is_hex.fm: -------------------------------------------------------------------------------- 1 | Char.is_hex(chr: Char): Bool 2 | Bool.or(Bool.and(U16.gte(chr,'0'),U16.lte(chr,'9')), 3 | Bool.or(Bool.and(U16.gte(chr,'a'),U16.lte(chr,'f')), 4 | Bool.or(Bool.and(U16.gte(chr,'A'),U16.lte(chr,'F')), 5 | false))) 6 | -------------------------------------------------------------------------------- /src/Char/newline.fm: -------------------------------------------------------------------------------- 1 | Char.newline: Char 2 | Char.new( 3 | Bit.o, Bit.o, Bit.o, Bit.o, 4 | Bit.o, Bit.o, Bit.o, Bit.o, 5 | Bit.o, Bit.o, Bit.o, Bit.o, 6 | Bit.i, Bit.o, Bit.i, Bit.o) 7 | -------------------------------------------------------------------------------- /src/Char/parse.fm: -------------------------------------------------------------------------------- 1 | Char.parse(str: String): Char.parse.type(str) 2 | case str { 3 | nil : Unit.new, 4 | cons: str.head 5 | } : Char.parse.type(str) -------------------------------------------------------------------------------- /src/Char/parse/type.fm: -------------------------------------------------------------------------------- 1 | Char.parse.type(str: String): Type 2 | case str { 3 | nil : Unit, 4 | cons: Char 5 | } -------------------------------------------------------------------------------- /src/Cmp.fm: -------------------------------------------------------------------------------- 1 | type Cmp { 2 | ltn, 3 | eql, 4 | gtn, 5 | } -------------------------------------------------------------------------------- /src/Cmp/as_eql.fm: -------------------------------------------------------------------------------- 1 | Cmp.as_eql(cmp: Cmp): Bool 2 | case cmp { 3 | ltn: Bool.false, 4 | eql: Bool.true, 5 | gtn: Bool.false, 6 | } -------------------------------------------------------------------------------- /src/Cmp/as_gte.fm: -------------------------------------------------------------------------------- 1 | Cmp.as_gte(cmp: Cmp): Bool 2 | case cmp { 3 | ltn: Bool.false, 4 | eql: Bool.true, 5 | gtn: Bool.true, 6 | } -------------------------------------------------------------------------------- /src/Cmp/as_gtn.fm: -------------------------------------------------------------------------------- 1 | Cmp.as_gtn(cmp: Cmp): Bool 2 | case cmp { 3 | ltn: Bool.false, 4 | eql: Bool.false, 5 | gtn: Bool.true, 6 | } -------------------------------------------------------------------------------- /src/Cmp/as_lte.fm: -------------------------------------------------------------------------------- 1 | Cmp.as_lte(cmp: Cmp): Bool 2 | case cmp { 3 | ltn: Bool.true, 4 | eql: Bool.true, 5 | gtn: Bool.false, 6 | } -------------------------------------------------------------------------------- /src/Cmp/as_ltn.fm: -------------------------------------------------------------------------------- 1 | Cmp.as_ltn(cmp: Cmp): Bool 2 | case cmp { 3 | ltn: Bool.true, 4 | eql: Bool.false, 5 | gtn: Bool.false, 6 | } -------------------------------------------------------------------------------- /src/Col32.fm: -------------------------------------------------------------------------------- 1 | Col32: Type 2 | U32 3 | -------------------------------------------------------------------------------- /src/Col32/new.fm: -------------------------------------------------------------------------------- 1 | Col32.new(r: U32, g: U32, b: U32, a: U32): Col32 2 | let col = 0u 3 | let col = U32.or(col, r) 4 | let col = U32.or(col, U32.shl(g, 8u)) 5 | let col = U32.or(col, U32.shl(b, 16u)) 6 | let col = U32.or(col, U32.shl(a, 24u)) 7 | col 8 | -------------------------------------------------------------------------------- /src/Debug/log.fm: -------------------------------------------------------------------------------- 1 | Debug.log(s: String, x: Unit -> A): A 2 | x(Unit.new) -------------------------------------------------------------------------------- /src/Either.fm: -------------------------------------------------------------------------------- 1 | type Either { 2 | left(value: A), 3 | right(value: B), 4 | } -------------------------------------------------------------------------------- /src/Either/bind.fm: -------------------------------------------------------------------------------- 1 | Either.bind(e: Either(A,B), f: B -> Either(A,C)): Either(A,C) 2 | case e { 3 | left: Either.left!!(e.value), 4 | right: f(e.value), 5 | } -------------------------------------------------------------------------------- /src/Either/functor.fm: -------------------------------------------------------------------------------- 1 | Either.functor: Functor(Either(A)) 2 | Functor.new(Either.map) -------------------------------------------------------------------------------- /src/Either/map.fm: -------------------------------------------------------------------------------- 1 | Either.map(f: B -> C, e: Either(A, B)): Either(A, C) 2 | case e { 3 | left: Either.left(e.value), 4 | right: Either.right(f(e.value)), 5 | } -------------------------------------------------------------------------------- /src/Either/monad.fm: -------------------------------------------------------------------------------- 1 | Either.monad: Monad(Either(A)) 2 | Monad.new(Either.bind, Either.right) -------------------------------------------------------------------------------- /src/Empty.fm: -------------------------------------------------------------------------------- 1 | type Empty { 2 | } -------------------------------------------------------------------------------- /src/Empty/absurd.fm: -------------------------------------------------------------------------------- 1 | Empty.absurd(x: Empty): P 2 | case x {} -------------------------------------------------------------------------------- /src/Equal.fm: -------------------------------------------------------------------------------- 1 | type Equal ~ (b: A) { 2 | refl ~ (b: a) 3 | } 4 | -------------------------------------------------------------------------------- /src/Equal/apply.fm: -------------------------------------------------------------------------------- 1 | Equal.apply B>(e: Equal(A,a,b)): Equal(B, f(a), f(b)) 2 | case e { 3 | refl: Equal.refl 4 | } : Equal(B, f(a), f(e.b)) 5 | -------------------------------------------------------------------------------- /src/Equal/cast.fm: -------------------------------------------------------------------------------- 1 | Equal.cast Type, e: Equal(A,a,b)>(x: P(a)): P(b) 2 | case e{ 3 | refl: x 4 | } : P(e.b) 5 | -------------------------------------------------------------------------------- /src/Equal/chain.fm: -------------------------------------------------------------------------------- 1 | Equal.chain(d: Equal(A,a,b), e: Equal(A,b,c)): Equal(A,a,c) 2 | case e { 3 | refl: d 4 | } : Equal(A, a, e.b) 5 | -------------------------------------------------------------------------------- /src/Equal/left.fm: -------------------------------------------------------------------------------- 1 | Equal.left(r: Equal(A, a, x), s: Equal(A, b, x)) 2 | : Equal(A, a, b) 3 | Equal.chain(r, Equal.mirror(s)) 4 | -------------------------------------------------------------------------------- /src/Equal/mirror.fm: -------------------------------------------------------------------------------- 1 | Equal.mirror(e: Equal(A, a, b)): Equal(A, b, a) 2 | case e { 3 | refl: Equal.refl 4 | } : Equal(A, e.b, a) 5 | -------------------------------------------------------------------------------- /src/Equal/rewrite.fm: -------------------------------------------------------------------------------- 1 | Equal.rewrite(e: Equal(A,a,b)) Type>(x: P(a)): P(b) 2 | case e { 3 | refl: x 4 | } : P(e.b) 5 | -------------------------------------------------------------------------------- /src/Equal/right.fm: -------------------------------------------------------------------------------- 1 | Equal.right(r: Equal(A, x, a), s: Equal(A, x, b)) 2 | : Equal(A, a, b) 3 | Equal.chain(Equal.mirror(r), s) 4 | -------------------------------------------------------------------------------- /src/Example/IsEven/A.fm: -------------------------------------------------------------------------------- 1 | Example.IsEven.A(n: Nat): Type 2 | {x: Nat} Nat.is_even(x) == true -------------------------------------------------------------------------------- /src/Example/IsEven/B.fm: -------------------------------------------------------------------------------- 1 | type Example.IsEven.B ~ (n: Nat) { 2 | zero ~ (n: 0) 3 | succ(n: Nat, e: Example.IsEven.B(n)) ~ (n: Nat.add(2,n)) 4 | } -------------------------------------------------------------------------------- /src/Example/Nat.fm: -------------------------------------------------------------------------------- 1 | type Example.Nat { 2 | zero 3 | succ(pred: Nat) 4 | } -------------------------------------------------------------------------------- /src/Example/Suit.fm: -------------------------------------------------------------------------------- 1 | type Example.Suit { 2 | diamonds 3 | clubs 4 | hearts 5 | spades 6 | } -------------------------------------------------------------------------------- /src/Example/black_friday_theorem.fm: -------------------------------------------------------------------------------- 1 | Example.black_friday_theorem(n: Nat): Example.half(Example.double(n)) == n 2 | case n { 3 | zero: refl 4 | succ: apply(Nat.succ, Example.black_friday_theorem(n.pred)) 5 | }! -------------------------------------------------------------------------------- /src/Example/double.fm: -------------------------------------------------------------------------------- 1 | Example.double(n: Nat): Nat 2 | case n { 3 | zero: 0 4 | succ: Nat.succ(Nat.succ(Example.double(n.pred))) 5 | } -------------------------------------------------------------------------------- /src/Example/greet.fm: -------------------------------------------------------------------------------- 1 | Example.greet: IO(Unit) 2 | do IO { 3 | IO.print("What is your name?") 4 | var name = IO.get_line 5 | IO.print("Hello, " | name | "!") 6 | Example.greet 7 | } -------------------------------------------------------------------------------- /src/Example/half.fm: -------------------------------------------------------------------------------- 1 | Example.half(n: Nat): Nat 2 | case n { 3 | zero: 0 4 | succ: case n.pred { 5 | zero: 0 6 | succ: Nat.succ(Example.half(n.pred.pred)) 7 | } 8 | } -------------------------------------------------------------------------------- /src/Example/hello_world.fm: -------------------------------------------------------------------------------- 1 | Example.hello_world: String 2 | "Hello, world!" -------------------------------------------------------------------------------- /src/Example/open_and_let.fm: -------------------------------------------------------------------------------- 1 | Example.open_and_let: Pair(Nat, String) 2 | let a = {5, "foo"} 3 | let b = {7, "bar"} 4 | open a 5 | let {b_fst, b_snd} = b 6 | {Nat.add(a.fst, b_fst), a.snd | b_snd} -------------------------------------------------------------------------------- /src/Example/suit_to_string.fm: -------------------------------------------------------------------------------- 1 | Example.suit_to_string(suit: Example.Suit): String 2 | case suit { 3 | diamonds: "diamonds" 4 | clubs: "clubs" 5 | hearts: "hearts" 6 | spades: "spades" 7 | } -------------------------------------------------------------------------------- /src/Example/sum.fm: -------------------------------------------------------------------------------- 1 | Example.sum(n: Nat): Nat 2 | case n { 3 | zero: 0 4 | succ: n + Example.sum(n.pred) 5 | } -------------------------------------------------------------------------------- /src/Example/theorem.fm: -------------------------------------------------------------------------------- 1 | Example.theorem(n: Nat): Nat.add(n,0) == n 2 | case n { 3 | zero: refl 4 | succ: apply(Nat.succ, Example.theorem(n.pred)) 5 | }! -------------------------------------------------------------------------------- /src/Example/two_is_even/A.fm: -------------------------------------------------------------------------------- 1 | Example.two_is_even.A: Example.IsEven.A(2) 2 | 2 ~ refl -------------------------------------------------------------------------------- /src/Example/two_is_even/B.fm: -------------------------------------------------------------------------------- 1 | Example.two_is_even.B: Example.IsEven.B(2) 2 | Example.IsEven.B.succ(_, Example.IsEven.B.zero) -------------------------------------------------------------------------------- /src/F64.fm: -------------------------------------------------------------------------------- 1 | type F64 { 2 | new(word: Word(64)) 3 | } -------------------------------------------------------------------------------- /src/F64/0.fm: -------------------------------------------------------------------------------- 1 | F64.0 : F64 2 | F64.parse_binary("0000000000000000000000000000000000000000000000000000000000000000") -------------------------------------------------------------------------------- /src/F64/1.fm: -------------------------------------------------------------------------------- 1 | F64.1 : F64 2 | F64.parse_binary("0000000000000000000000000000000000000000000000000000111111111100") -------------------------------------------------------------------------------- /src/F64/180.fm: -------------------------------------------------------------------------------- 1 | F64.180 : F64 2 | F64.parse_binary("0000000000000000000000000000000000000000000000010110011000000010") -------------------------------------------------------------------------------- /src/F64/2.fm: -------------------------------------------------------------------------------- 1 | F64.2 : F64 2 | F64.parse_binary("0000000000000000000000000000000000000000000000000000000000000010") -------------------------------------------------------------------------------- /src/F64/256.fm: -------------------------------------------------------------------------------- 1 | F64.256 : F64 2 | F64.parse_binary("0000000000000000000000000000000000000000000000000000111000000010") -------------------------------------------------------------------------------- /src/F64/Boundary.fm: -------------------------------------------------------------------------------- 1 | type F64.Boundary { 2 | new(pts: List(F64.V3)) 3 | } -------------------------------------------------------------------------------- /src/F64/Circle.fm: -------------------------------------------------------------------------------- 1 | type F64.Circle { 2 | new(pos: F64.V3, rad: F64) 3 | } -------------------------------------------------------------------------------- /src/F64/Line.fm: -------------------------------------------------------------------------------- 1 | type F64.Line { 2 | new(pos: F64.V3, dir: F64.V3) 3 | } -------------------------------------------------------------------------------- /src/F64/Ordering.fm: -------------------------------------------------------------------------------- 1 | type F64.Ordering { 2 | LT, 3 | EQ, 4 | GT 5 | } -------------------------------------------------------------------------------- /src/F64/Segment.fm: -------------------------------------------------------------------------------- 1 | type F64.Segment { 2 | new(a: F64.V3, b: F64.V3) 3 | } -------------------------------------------------------------------------------- /src/F64/V3.fm: -------------------------------------------------------------------------------- 1 | type F64.V3 { 2 | new(x: F64, y: F64, z: F64) 3 | } -------------------------------------------------------------------------------- /src/F64/V3/add.fm: -------------------------------------------------------------------------------- 1 | F64.V3.add(a: F64.V3, b: F64.V3): F64.V3 2 | open a 3 | open b 4 | let c.x = F64.add(a.x, a.x) 5 | let c.y = F64.add(a.y, b.y) 6 | let c.z = F64.add(a.z, b.z) 7 | F64.V3.new(c.x, c.y, c.z) -------------------------------------------------------------------------------- /src/F64/V3/dist.fm: -------------------------------------------------------------------------------- 1 | F64.V3.dist(a: F64.V3, b: F64.V3): F64 2 | F64.sqrt(F64.V3.sqr_dist(a, b)) -------------------------------------------------------------------------------- /src/F64/V3/dot.fm: -------------------------------------------------------------------------------- 1 | F64.V3.dot(a: F64.V3, b: F64.V3): F64 2 | open a 3 | open b 4 | let res = F64.0 5 | let res = F64.add(res, F64.mul(a.x, b.x)) 6 | let res = F64.add(res, F64.mul(a.y, b.y)) 7 | let res = F64.add(res, F64.mul(a.z, b.z)) 8 | res -------------------------------------------------------------------------------- /src/F64/V3/eql.fm: -------------------------------------------------------------------------------- 1 | F64.V3.eql(a: F64.V3, b: F64.V3): Bool 2 | open a 3 | open b 4 | let same_x = F64.eql(a.x, b.x) 5 | let same_y = F64.eql(a.y, b.y) 6 | let same_z = F64.eql(a.z, b.z) 7 | Bool.and(same_x, Bool.and(same_y, same_z)) -------------------------------------------------------------------------------- /src/F64/V3/get_x.fm: -------------------------------------------------------------------------------- 1 | F64.V3.get_x(v: F64.V3): F64 2 | open v 3 | v.x -------------------------------------------------------------------------------- /src/F64/V3/get_y.fm: -------------------------------------------------------------------------------- 1 | F64.V3.get_y(v: F64.V3): F64 2 | open v 3 | v.y -------------------------------------------------------------------------------- /src/F64/V3/get_z.fm: -------------------------------------------------------------------------------- 1 | F64.V3.get_z(v: F64.V3): F64 2 | open v 3 | v.z -------------------------------------------------------------------------------- /src/F64/V3/ltn.fm: -------------------------------------------------------------------------------- 1 | F64.V3.ltn(a: F64.V3, b: F64.V3): Bool 2 | let len_a = F64.V3.len(a) 3 | let len_b = F64.V3.len(b) 4 | F64.ltn(len_a, len_b) -------------------------------------------------------------------------------- /src/F64/V3/map.fm: -------------------------------------------------------------------------------- 1 | F64.V3.map(fn: F64 -> F64, v: F64.V3): F64.V3 2 | open v 3 | F64.V3.new(fn(v.x), fn(v.y), fn(v.z)) -------------------------------------------------------------------------------- /src/F64/V3/map_x.fm: -------------------------------------------------------------------------------- 1 | F64.V3.map_x(fn: F64 -> F64, v: F64.V3): F64.V3 2 | open v 3 | F64.V3.new(fn(v.x), v.y, v.z) -------------------------------------------------------------------------------- /src/F64/V3/map_y.fm: -------------------------------------------------------------------------------- 1 | F64.V3.map_y(fn: F64 -> F64, v: F64.V3): F64.V3 2 | open v 3 | F64.V3.new(v.x, fn(v.y), v.z) -------------------------------------------------------------------------------- /src/F64/V3/map_z.fm: -------------------------------------------------------------------------------- 1 | F64.V3.map_z(fn: F64 -> F64, v: F64.V3): F64.V3 2 | open v 3 | F64.V3.new(v.x, v.y, fn(v.z)) -------------------------------------------------------------------------------- /src/F64/V3/mul.fm: -------------------------------------------------------------------------------- 1 | F64.V3.mul(a: F64.V3, b: F64.V3): F64.V3 2 | open a 3 | open b 4 | let c.x = F64.mul(a.x, a.x) 5 | let c.y = F64.mul(a.y, b.y) 6 | let c.z = F64.mul(a.z, b.z) 7 | F64.V3.new(c.x, c.y, c.z) -------------------------------------------------------------------------------- /src/F64/V3/norm.fm: -------------------------------------------------------------------------------- 1 | F64.V3.norm(v: F64.V3): F64.V3 2 | open v 3 | let len = F64.V3.len(v) 4 | let new_x = F64.div(v.x, len) 5 | let new_y = F64.div(v.y, len) 6 | let new_z = F64.div(v.z, len) 7 | F64.V3.new(new_x, new_y, new_z) -------------------------------------------------------------------------------- /src/F64/V3/point_segment_dist.fm: -------------------------------------------------------------------------------- 1 | F64.V3.point_segment_dist(p: F64.V3, s: F64.Segment): F64 2 | F64.sqrt(F64.V3.point_segment_sqrdist(p, s)) -------------------------------------------------------------------------------- /src/F64/V3/rot_90.fm: -------------------------------------------------------------------------------- 1 | F64.V3.rot_90(v: F64.V3): F64.V3 2 | open v 3 | F64.V3.new(v.y, F64.sub(F64.0, v.x), v.z) -------------------------------------------------------------------------------- /src/F64/V3/scale.fm: -------------------------------------------------------------------------------- 1 | F64.V3.scale(k: F64, v: F64.V3): F64.V3 2 | open v 3 | let new_x = F64.mul(k, v.x) 4 | let new_y = F64.mul(k, v.y) 5 | let new_z = F64.mul(k, v.z) 6 | F64.V3.new(new_x, new_y, new_z) -------------------------------------------------------------------------------- /src/F64/V3/sub.fm: -------------------------------------------------------------------------------- 1 | F64.V3.sub(a: F64.V3, b: F64.V3): F64.V3 2 | open a 3 | open b 4 | let c.x = F64.sub(a.x, a.x) 5 | let c.y = F64.sub(a.y, b.y) 6 | let c.z = F64.sub(a.z, b.z) 7 | F64.V3.new(c.x, c.y, c.z) -------------------------------------------------------------------------------- /src/F64/V3/to_pos32.fm: -------------------------------------------------------------------------------- 1 | F64.V3.to_pos32(pos: F64.V3): Pos32 2 | F64.V3.to_pos32(pos) -------------------------------------------------------------------------------- /src/F64/_1.fm: -------------------------------------------------------------------------------- 1 | F64._1 : F64 2 | F64.parse_binary("0000000000000000000000000000000000000000000000000000111111111101") -------------------------------------------------------------------------------- /src/F64/acos.fm: -------------------------------------------------------------------------------- 1 | F64.acos: F64 -> F64 //prim// 2 | F64.acos -------------------------------------------------------------------------------- /src/F64/add.fm: -------------------------------------------------------------------------------- 1 | F64.add: F64 -> F64 -> F64 //prim// 2 | F64.add -------------------------------------------------------------------------------- /src/F64/asin.fm: -------------------------------------------------------------------------------- 1 | F64.asin: F64 -> F64 //prim// 2 | F64.asin -------------------------------------------------------------------------------- /src/F64/atan.fm: -------------------------------------------------------------------------------- 1 | F64.atan: F64 -> F64 -> F64 //prim// 2 | F64.atan -------------------------------------------------------------------------------- /src/F64/cmp.fm: -------------------------------------------------------------------------------- 1 | F64.cmp(x: F64, y: F64): Cmp 2 | open x 3 | open y 4 | Word.cmp<64>(x.word, y.word) -------------------------------------------------------------------------------- /src/F64/compare_numbers.fm: -------------------------------------------------------------------------------- 1 | F64.compare_numbers(a: F64, b: F64): F64.Ordering 2 | case F64.eql(a, b){ 3 | true : F64.Ordering.EQ 4 | false: case F64.ltn(b, a){ 5 | true : F64.Ordering.GT 6 | false: F64.Ordering.LT 7 | } 8 | } -------------------------------------------------------------------------------- /src/F64/cos.fm: -------------------------------------------------------------------------------- 1 | F64.cos: F64 -> F64 //prim// 2 | F64.cos -------------------------------------------------------------------------------- /src/F64/div.fm: -------------------------------------------------------------------------------- 1 | F64.div: F64 -> F64 -> F64 //prim// 2 | F64.div -------------------------------------------------------------------------------- /src/F64/eql.fm: -------------------------------------------------------------------------------- 1 | F64.eql(x: F64, y: F64): Bool 2 | open x 3 | open y 4 | Word.eql<64>(x.word, y.word) -------------------------------------------------------------------------------- /src/F64/exp.fm: -------------------------------------------------------------------------------- 1 | F64.exp: F64 -> F64 -> F64 //prim// 2 | F64.exp -------------------------------------------------------------------------------- /src/F64/floor.fm: -------------------------------------------------------------------------------- 1 | F64.floor(x: F64): F64 2 | let ltn_zero = F64.if!(F64.from_bool(F64.ltn(x, F64.0)), F64.1, F64.0) 3 | F64.sub(F64.sub(x, F64.mod(x, F64.1)), ltn_zero) -------------------------------------------------------------------------------- /src/F64/from_bool.fm: -------------------------------------------------------------------------------- 1 | F64.from_bool(b: Bool): F64 2 | case b { 3 | true : F64.1, 4 | false: F64.0 5 | } -------------------------------------------------------------------------------- /src/F64/gte.fm: -------------------------------------------------------------------------------- 1 | F64.gte(a: F64, b: F64): Bool 2 | open a 3 | open b 4 | Word.gte<64>(a.word, b.word) -------------------------------------------------------------------------------- /src/F64/gtn.fm: -------------------------------------------------------------------------------- 1 | F64.gtn(a: F64, b: F64): Bool 2 | open a 3 | open b 4 | Word.gtn<64>(a.word, b.word) -------------------------------------------------------------------------------- /src/F64/if.fm: -------------------------------------------------------------------------------- 1 | F64.if(x: F64, ct: A, cf: A): A 2 | case F64.eql(x, F64.0) { 3 | true : cf, 4 | false: ct 5 | } -------------------------------------------------------------------------------- /src/F64/is_between.fm: -------------------------------------------------------------------------------- 1 | F64.is_between(a: F64, b: F64, x: F64): Bool 2 | let a_eql_x = F64.eql(a, x) 3 | let a_ltn_x = F64.ltn(a, x) 4 | let x_ltn_b = F64.ltn(x, b) 5 | Bool.or(a_eql_x, Bool.and(a_ltn_x, x_ltn_b)) -------------------------------------------------------------------------------- /src/F64/log.fm: -------------------------------------------------------------------------------- 1 | F64.log: F64 -> F64 //prim// 2 | F64.log -------------------------------------------------------------------------------- /src/F64/lte.fm: -------------------------------------------------------------------------------- 1 | F64.lte(a: F64, b: F64): Bool 2 | open a 3 | open b 4 | Word.lte<64>(a.word, b.word) -------------------------------------------------------------------------------- /src/F64/ltn.fm: -------------------------------------------------------------------------------- 1 | F64.ltn(a: F64, b: F64): Bool 2 | open a 3 | open b 4 | Word.ltn<64>(a.word, b.word) -------------------------------------------------------------------------------- /src/F64/max.fm: -------------------------------------------------------------------------------- 1 | F64.max: F64 -> F64 -> F64 //prim// 2 | F64.max -------------------------------------------------------------------------------- /src/F64/min.fm: -------------------------------------------------------------------------------- 1 | F64.min: F64 -> F64 -> F64 //prim// 2 | F64.min -------------------------------------------------------------------------------- /src/F64/mod.fm: -------------------------------------------------------------------------------- 1 | F64.mod: F64 -> F64 -> F64 //prim// 2 | F64.mod -------------------------------------------------------------------------------- /src/F64/mul.fm: -------------------------------------------------------------------------------- 1 | F64.mul: F64 -> F64 -> F64 //prim// 2 | F64.mul -------------------------------------------------------------------------------- /src/F64/parse.fm: -------------------------------------------------------------------------------- 1 | F64.parse: String -> F64 2 | F64.parse -------------------------------------------------------------------------------- /src/F64/parse_binary.fm: -------------------------------------------------------------------------------- 1 | F64.parse_binary(str: String): F64 2 | F64.new(Word.from_bits(64, String.to_bits(str))) -------------------------------------------------------------------------------- /src/F64/pi.fm: -------------------------------------------------------------------------------- 1 | F64.pi : F64 2 | F64.parse_binary("0001100010110100001000100010101011011111100001001001000000000010") -------------------------------------------------------------------------------- /src/F64/pow.fm: -------------------------------------------------------------------------------- 1 | F64.pow: F64 -> F64 -> F64 //prim// 2 | F64.pow -------------------------------------------------------------------------------- /src/F64/rotate2d.fm: -------------------------------------------------------------------------------- 1 | F64.rotate2d(x: F64, y: F64, a: F64): Pair(F64, F64) 2 | let x2 = F64.sub(F64.mul(x, F64.cos(a)), F64.mul(y, F64.sin(a))) 3 | let y2 = F64.add(F64.mul(x, F64.sin(a)), F64.mul(y, F64.cos(a))) 4 | Pair.new!!(x2, y2) -------------------------------------------------------------------------------- /src/F64/sin.fm: -------------------------------------------------------------------------------- 1 | F64.sin: F64 -> F64 //prim// 2 | F64.sin -------------------------------------------------------------------------------- /src/F64/sqrt.fm: -------------------------------------------------------------------------------- 1 | F64.sqrt(n: F64): F64 //prim// 2 | F64.pow(n, F64.div(F64.1, F64.2)) -------------------------------------------------------------------------------- /src/F64/sub.fm: -------------------------------------------------------------------------------- 1 | F64.sub: F64 -> F64 -> F64 //prim// 2 | F64.sub -------------------------------------------------------------------------------- /src/F64/tan.fm: -------------------------------------------------------------------------------- 1 | F64.tan: F64 -> F64 //prim// 2 | F64.tan -------------------------------------------------------------------------------- /src/F64/to_u32.fm: -------------------------------------------------------------------------------- 1 | F64.to_u32(a: F64): U32 2 | F64.to_u32(a) -------------------------------------------------------------------------------- /src/Fm.fm: -------------------------------------------------------------------------------- 1 | Fm: IO(Unit) 2 | do IO { 3 | let _ = Fm.to_core.io.one; 4 | let _ = Fm.checker.io.one; 5 | let _ = Fm.checker.io.file; 6 | let _ = Fm.checker.code; 7 | let _ = Fm.Term.read; 8 | return Unit.new; 9 | } 10 | -------------------------------------------------------------------------------- /src/Fm/Binder.fm: -------------------------------------------------------------------------------- 1 | type Fm.Binder { 2 | new( 3 | eras: Bool, 4 | name: Fm.Name, 5 | term: Fm.Term, 6 | ) 7 | } -------------------------------------------------------------------------------- /src/Fm/Check.fm: -------------------------------------------------------------------------------- 1 | type Fm.Check { 2 | result( 3 | value: Maybe(V), // the returned value 4 | errors: List(Fm.Error), // a list of errors 5 | ), 6 | } -------------------------------------------------------------------------------- /src/Fm/Check/monad.fm: -------------------------------------------------------------------------------- 1 | Fm.Check.monad: Monad(Fm.Check) 2 | Monad.new(Fm.Check.bind, Fm.Check.pure) -------------------------------------------------------------------------------- /src/Fm/Check/none.fm: -------------------------------------------------------------------------------- 1 | Fm.Check.none: Fm.Check(A) 2 | Fm.Check.result(Maybe.none, []) -------------------------------------------------------------------------------- /src/Fm/Check/pure.fm: -------------------------------------------------------------------------------- 1 | Fm.Check.pure(value: V): Fm.Check(V) 2 | Fm.Check.result(Maybe.some(value), []) -------------------------------------------------------------------------------- /src/Fm/Check/value.fm: -------------------------------------------------------------------------------- 1 | Fm.Check.value(chk: Fm.Check(A)): Maybe(A) 2 | case chk { 3 | result: chk.value 4 | } -------------------------------------------------------------------------------- /src/Fm/Constructor.fm: -------------------------------------------------------------------------------- 1 | type Fm.Constructor { 2 | new( 3 | name: Fm.Name, 4 | args: List(Fm.Binder), 5 | inds: List(Fm.Binder), 6 | ) 7 | } -------------------------------------------------------------------------------- /src/Fm/Constructor/build_term.fm: -------------------------------------------------------------------------------- 1 | Fm.Constructor.build_term(type: Fm.Datatype, ctor: Fm.Constructor): Fm.Term 2 | case type { 3 | new: case ctor { 4 | new: Fm.Constructor.build_term.go(type, ctor, type.name, type.pars, ctor.args) 5 | } 6 | } -------------------------------------------------------------------------------- /src/Fm/Constructor/build_term/opt.fm: -------------------------------------------------------------------------------- 1 | Fm.Constructor.build_term.opt(type: Fm.Datatype, ctor: Fm.Constructor): Fm.Term 2 | case type { 3 | new: Fm.Constructor.build_term.opt.go(type, ctor, type.ctrs) 4 | } -------------------------------------------------------------------------------- /src/Fm/Context.fm: -------------------------------------------------------------------------------- 1 | Fm.Context: Type 2 | List(Pair(Fm.Name,Fm.Term)) -------------------------------------------------------------------------------- /src/Fm/Context/find.fm: -------------------------------------------------------------------------------- 1 | Fm.Context.find(name: Fm.Name, ctx: Fm.Context): Maybe(Fm.Term) 2 | //log("->", name) 3 | let {name, skip} = Fm.Context.get_name_skips(name) 4 | //log("~>", name, Nat.show(skip)) 5 | Fm.Context.find.go(name, skip, ctx) -------------------------------------------------------------------------------- /src/Fm/Context/names.fm: -------------------------------------------------------------------------------- 1 | Fm.Context.names(ctx: Fm.Context): List(Fm.Name) 2 | List.mapped!(ctx)!((x) Pair.fst!!(x)) -------------------------------------------------------------------------------- /src/Fm/Datatype.fm: -------------------------------------------------------------------------------- 1 | type Fm.Datatype { 2 | new( 3 | name: Fm.Name, 4 | pars: List(Fm.Binder), 5 | inds: List(Fm.Binder), 6 | ctrs: List(Fm.Constructor), 7 | ) 8 | } -------------------------------------------------------------------------------- /src/Fm/Datatype/build_term.fm: -------------------------------------------------------------------------------- 1 | Fm.Datatype.build_term(type: Fm.Datatype): Fm.Term 2 | case type { 3 | new: Fm.Datatype.build_term.go(type, type.name, type.pars, type.inds), 4 | } -------------------------------------------------------------------------------- /src/Fm/Datatype/build_term/constructor.fm: -------------------------------------------------------------------------------- 1 | Fm.Datatype.build_term.constructor(type: Fm.Datatype, ctor: Fm.Constructor): Fm.Term 2 | case ctor { 3 | new: Fm.Datatype.build_term.constructor.go(type, ctor, ctor.args), 4 | } -------------------------------------------------------------------------------- /src/Fm/Datatype/build_term/constructors.fm: -------------------------------------------------------------------------------- 1 | Fm.Datatype.build_term.constructors(type: Fm.Datatype): Fm.Term 2 | case type { 3 | new: Fm.Datatype.build_term.constructors.go(type, type.name, type.ctrs) 4 | } -------------------------------------------------------------------------------- /src/Fm/Datatype/build_term/motive.fm: -------------------------------------------------------------------------------- 1 | Fm.Datatype.build_term.motive( 2 | type: Fm.Datatype, 3 | ): Fm.Term 4 | case type { 5 | new: Fm.Datatype.build_term.motive.go(type, type.name, type.inds), 6 | } -------------------------------------------------------------------------------- /src/Fm/Datatype/build_type.fm: -------------------------------------------------------------------------------- 1 | Fm.Datatype.build_type(type: Fm.Datatype): Fm.Term 2 | case type { 3 | new: Fm.Datatype.build_type.go(type, type.name, type.pars, type.inds), 4 | } -------------------------------------------------------------------------------- /src/Fm/Def.fm: -------------------------------------------------------------------------------- 1 | type Fm.Def { 2 | new( 3 | file: String, 4 | code: String, 5 | orig: Pair(Nat, Nat), 6 | name: Fm.Name, 7 | term: Fm.Term, 8 | type: Fm.Term, 9 | isct: Bool, 10 | arit: Nat, 11 | stat: Fm.Status, 12 | ), 13 | } 14 | -------------------------------------------------------------------------------- /src/Fm/Defs.fm: -------------------------------------------------------------------------------- 1 | Fm.Defs: Type 2 | Map(Fm.Def) -------------------------------------------------------------------------------- /src/Fm/Letter.fm: -------------------------------------------------------------------------------- 1 | Fm.Letter: Type 2 | Char -------------------------------------------------------------------------------- /src/Fm/MPath.fm: -------------------------------------------------------------------------------- 1 | Fm.MPath: Type 2 | Maybe(Fm.Path) -------------------------------------------------------------------------------- /src/Fm/MPath/i.fm: -------------------------------------------------------------------------------- 1 | Fm.MPath.i(path: Maybe(Fm.Path)): Maybe(Fm.Path) 2 | Maybe.mapped!(path)!(Fm.Path.i) -------------------------------------------------------------------------------- /src/Fm/MPath/nil.fm: -------------------------------------------------------------------------------- 1 | Fm.MPath.nil: Maybe(Fm.Path) 2 | Maybe.some!(Fm.Path.nil) -------------------------------------------------------------------------------- /src/Fm/MPath/o.fm: -------------------------------------------------------------------------------- 1 | Fm.MPath.o(path: Maybe(Fm.Path)): Maybe(Fm.Path) 2 | Maybe.mapped!(path)!(Fm.Path.o) -------------------------------------------------------------------------------- /src/Fm/MPath/to_bits.fm: -------------------------------------------------------------------------------- 1 | Fm.MPath.to_bits(path: Maybe(Fm.Path)): Bits 2 | case path { 3 | none: Bits.e, 4 | some: path.value(Bits.e), 5 | } -------------------------------------------------------------------------------- /src/Fm/Name.fm: -------------------------------------------------------------------------------- 1 | Fm.Name: Type 2 | String -------------------------------------------------------------------------------- /src/Fm/Name/eql.fm: -------------------------------------------------------------------------------- 1 | Fm.Name.eql(a: Fm.Name, b: Fm.Name): Bool 2 | String.eql(a, b) -------------------------------------------------------------------------------- /src/Fm/Name/read.fm: -------------------------------------------------------------------------------- 1 | Fm.Name.read(str: String): Fm.Name 2 | str -------------------------------------------------------------------------------- /src/Fm/Name/show.fm: -------------------------------------------------------------------------------- 1 | Fm.Name.show(name: Fm.Name): String 2 | name -------------------------------------------------------------------------------- /src/Fm/Parser/add.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.add: Nat -> Fm.Term -> Parser(Fm.Term) 2 | Fm.Parser.op("+", "Nat.add") -------------------------------------------------------------------------------- /src/Fm/Parser/application/hole.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.application.hole(init: Nat, term: Fm.Term): Parser(Fm.Term) 2 | do Parser { 3 | Fm.Parser.text("!"); 4 | var orig = Fm.Parser.stop(init); 5 | return Fm.Term.ori(orig, Fm.Term.app(term, Fm.Term.hol(Bits.e))); 6 | } -------------------------------------------------------------------------------- /src/Fm/Parser/binder.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.binder: Parser(List(Fm.Binder)) 2 | do Parser { 3 | var lists = Parser.many1!(Parser.first_of!([ 4 | Fm.Parser.binder.homo(Bool.true), 5 | Fm.Parser.binder.homo(Bool.false), 6 | ])); 7 | return List.flatten!(lists); 8 | } -------------------------------------------------------------------------------- /src/Fm/Parser/case/case.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.case.case: Parser(Pair(Fm.Name, Fm.Term)) 2 | do Parser { 3 | var name = Fm.Parser.name1; 4 | Fm.Parser.text(":"); 5 | var term = Fm.Parser.term; 6 | Parser.maybe!(Fm.Parser.text(",")); 7 | return {name, term}; 8 | } -------------------------------------------------------------------------------- /src/Fm/Parser/div.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.div: Nat -> Fm.Term -> Parser(Fm.Term) 2 | Fm.Parser.op("/", "Nat.div") -------------------------------------------------------------------------------- /src/Fm/Parser/do.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.do: Parser(Fm.Term) 2 | do Parser { 3 | Fm.Parser.text("do "); 4 | var name = Fm.Parser.name1; 5 | Fm.Parser.text("{"); 6 | var term = Fm.Parser.do.statements(name); 7 | Fm.Parser.text("}"); 8 | return term; 9 | } -------------------------------------------------------------------------------- /src/Fm/Parser/file/end.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.file.end(file: String, code: String, defs: Fm.Defs): Parser(Fm.Defs) 2 | do Parser { 3 | Fm.Parser.spaces; 4 | Parser.eof; 5 | return defs; 6 | } -------------------------------------------------------------------------------- /src/Fm/Parser/hole.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.hole: Parser(Fm.Term) 2 | do Parser { 3 | var init = Fm.Parser.init; 4 | Fm.Parser.text("_"); 5 | var orig = Fm.Parser.stop(init); 6 | return Fm.Term.ori(orig, Fm.Term.hol(Bits.e)); 7 | } -------------------------------------------------------------------------------- /src/Fm/Parser/init.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.init: Parser(Nat) 2 | do Parser { 3 | Fm.Parser.spaces; 4 | var from = Parser.get_index; 5 | return from; 6 | } -------------------------------------------------------------------------------- /src/Fm/Parser/item.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.item(parser: Parser(V)): Parser(V) 2 | do Parser { 3 | Fm.Parser.spaces; 4 | var value = parser; 5 | Parser.maybe!(Fm.Parser.text(",")); 6 | return value; 7 | } -------------------------------------------------------------------------------- /src/Fm/Parser/make_lambda.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.make_lambda(names: List(Fm.Name), body: Fm.Term): Fm.Term 2 | case names { 3 | nil: body, 4 | cons: Fm.Term.lam(names.head, (x) Fm.Parser.make_lambda(names.tail, body)), 5 | } -------------------------------------------------------------------------------- /src/Fm/Parser/mod.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.mod: Nat -> Fm.Term -> Parser(Fm.Term) 2 | Fm.Parser.op("%", "Nat.mod") -------------------------------------------------------------------------------- /src/Fm/Parser/mul.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.mul: Nat -> Fm.Term -> Parser(Fm.Term) 2 | Fm.Parser.op("*", "Nat.mul") -------------------------------------------------------------------------------- /src/Fm/Parser/name.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.name: Parser(Fm.Name) 2 | do Parser { 3 | Fm.Parser.spaces; 4 | var chrs = Parser.many(Fm.Parser.letter); 5 | return List.fold!(chrs)!(String.nil, String.cons); 6 | } -------------------------------------------------------------------------------- /src/Fm/Parser/name1.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.name1: Parser(Fm.Name) 2 | do Parser { 3 | Fm.Parser.spaces; 4 | var chrs = Parser.many1(Fm.Parser.letter); 5 | return List.fold!(chrs)!(String.nil, String.cons); 6 | } -------------------------------------------------------------------------------- /src/Fm/Parser/name_term.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.name_term: Parser(Pair(Fm.Name, Fm.Term)) 2 | do Parser { 3 | var name = Fm.Parser.name; 4 | Fm.Parser.text(":"); 5 | var type = Fm.Parser.term; 6 | return {name, type}; 7 | } -------------------------------------------------------------------------------- /src/Fm/Parser/nat.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.nat: Parser(Fm.Term) 2 | do Parser { 3 | var init = Fm.Parser.init; 4 | Fm.Parser.spaces; 5 | var natx = Parser.nat; 6 | var orig = Fm.Parser.stop(init); 7 | return Fm.Term.ori(orig, Fm.Term.nat(natx)); 8 | } -------------------------------------------------------------------------------- /src/Fm/Parser/parenthesis.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.parenthesis: Parser(Fm.Term) 2 | do Parser { 3 | Fm.Parser.text("("); 4 | var term = Fm.Parser.term; 5 | Fm.Parser.text(")"); 6 | return term; 7 | } -------------------------------------------------------------------------------- /src/Fm/Parser/stop.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.stop(from: Nat): Parser(Pair(Nat,Nat)) 2 | do Parser { 3 | var upto = Parser.get_index; 4 | let orig = {from, upto}; 5 | return orig; 6 | } -------------------------------------------------------------------------------- /src/Fm/Parser/sub.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.sub: Nat -> Fm.Term -> Parser(Fm.Term) 2 | Fm.Parser.op("+", "Nat.add") -------------------------------------------------------------------------------- /src/Fm/Parser/text.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.text(text: String): Parser(Unit) 2 | do Parser { 3 | Fm.Parser.spaces; 4 | Parser.text(text); 5 | } -------------------------------------------------------------------------------- /src/Fm/Parser/type.fm: -------------------------------------------------------------------------------- 1 | Fm.Parser.type: Parser(Fm.Term) 2 | do Parser { 3 | var init = Fm.Parser.init; 4 | Fm.Parser.text("Type"); 5 | var orig = Fm.Parser.stop(init); 6 | return Fm.Term.ori(orig, Fm.Term.typ); 7 | } -------------------------------------------------------------------------------- /src/Fm/Path.fm: -------------------------------------------------------------------------------- 1 | Fm.Path: Type 2 | Bits -> Bits -------------------------------------------------------------------------------- /src/Fm/Path/i.fm: -------------------------------------------------------------------------------- 1 | Fm.Path.i(path: Fm.Path): Fm.Path 2 | (x) path(Bits.i(x)) -------------------------------------------------------------------------------- /src/Fm/Path/nil.fm: -------------------------------------------------------------------------------- 1 | Fm.Path.nil: Fm.Path 2 | (x) x -------------------------------------------------------------------------------- /src/Fm/Path/o.fm: -------------------------------------------------------------------------------- 1 | Fm.Path.o(path: Fm.Path): Fm.Path 2 | (x) path(Bits.o(x)) -------------------------------------------------------------------------------- /src/Fm/Path/to_bits.fm: -------------------------------------------------------------------------------- 1 | Fm.Path.to_bits(path: Fm.Path): Bits 2 | path(Bits.e) -------------------------------------------------------------------------------- /src/Fm/Prim.fm: -------------------------------------------------------------------------------- 1 | type Fm.Prim { 2 | bool, 3 | nat, 4 | u16, 5 | string, 6 | data(ctrs: List(Nat)), 7 | //bits, 8 | } -------------------------------------------------------------------------------- /src/Fm/SmartMotive/nams.fm: -------------------------------------------------------------------------------- 1 | Fm.SmartMotive.nams(name: Fm.Name, type: Fm.Term, defs: Fm.Defs): List(Fm.Name) 2 | case Fm.Term.reduce(type, defs) as type { 3 | all: Fm.SmartMotive.nams.cont(name, type.xtyp, [], defs), 4 | _: [], 5 | } -------------------------------------------------------------------------------- /src/Fm/Status.fm: -------------------------------------------------------------------------------- 1 | type Fm.Status { 2 | init, 3 | wait, 4 | done, 5 | fail(errors: List(Fm.Error)), 6 | } -------------------------------------------------------------------------------- /src/Fm/Synth/files_of.fm: -------------------------------------------------------------------------------- 1 | Fm.Synth.files_of(name: Fm.Name): List(String) 2 | List.reverse!(Fm.Synth.files_of.make(String.split(name, "."), "")) -------------------------------------------------------------------------------- /src/Fm/Synth/load.fm: -------------------------------------------------------------------------------- 1 | Fm.Synth.load(name: Fm.Name, defs: Fm.Defs): IO(Maybe(Fm.Defs)) 2 | Fm.Synth.load.go(name, Fm.Synth.files_of(name), defs) -------------------------------------------------------------------------------- /src/Fm/Term/identical.fm: -------------------------------------------------------------------------------- 1 | Fm.Term.identical(a: Fm.Term, b: Fm.Term, lv: Nat): Bool 2 | let ah = Fm.Term.serialize(a, lv, lv, Bits.o, Bits.e); 3 | let bh = Fm.Term.serialize(b, lv, lv, Bits.i, Bits.e); 4 | Bits.eql(ah, bh) -------------------------------------------------------------------------------- /src/Fm/Term/read.fm: -------------------------------------------------------------------------------- 1 | Fm.Term.read(code: String): Maybe(Fm.Term) 2 | case Fm.Parser.term(0,code) as parsed { 3 | error: Maybe.none!, 4 | value: Maybe.some!(parsed.val), 5 | } -------------------------------------------------------------------------------- /src/Fm/Term/serialize/name.fm: -------------------------------------------------------------------------------- 1 | Fm.Term.serialize.name(name: String): Bits 2 | Fm.Name.to_bits(name) -------------------------------------------------------------------------------- /src/Fm/Term/show.fm: -------------------------------------------------------------------------------- 1 | Fm.Term.show(term: Fm.Term): String 2 | Fm.Term.show.go(term, Maybe.none!) -------------------------------------------------------------------------------- /src/Fm/Term/show/as_nat.fm: -------------------------------------------------------------------------------- 1 | Fm.Term.show.as_nat(term: Fm.Term): Maybe(String) 2 | Maybe.mapped!(Fm.Term.show.as_nat.go(term))!(Nat.show) -------------------------------------------------------------------------------- /src/Fm/Term/show/is_ref.fm: -------------------------------------------------------------------------------- 1 | Fm.Term.show.is_ref(term: Fm.Term, name: Fm.Name): Bool 2 | case term { 3 | ref: String.eql(name, term.name), 4 | _: Bool.false, 5 | } -------------------------------------------------------------------------------- /src/Fm/backslash.fm: -------------------------------------------------------------------------------- 1 | Fm.backslash: Char 2 | Nat.to_u16(92) -------------------------------------------------------------------------------- /src/Fm/escape.fm: -------------------------------------------------------------------------------- 1 | Fm.escape.go(str: String, result: String): String 2 | case str { 3 | nil: String.reverse(result) 4 | cons: Fm.escape.go(str.tail, String.reverse(Fm.escape.char(str.head)) | result) 5 | } 6 | 7 | Fm.escape(str: String): String 8 | Fm.escape.go(str, "") 9 | -------------------------------------------------------------------------------- /src/Fm/get.fm: -------------------------------------------------------------------------------- 1 | Fm.get(name: Fm.Name, map: Map(A)): Maybe(A) 2 | Map.get(Fm.Name.to_bits(name), map) -------------------------------------------------------------------------------- /src/Fm/highlight.fm: -------------------------------------------------------------------------------- 1 | Fm.highlight( 2 | code: String, 3 | idx0: Nat, 4 | idx1: Nat, 5 | ): String 6 | Fm.highlight.tc(code, idx0, idx1, 0, 1, Maybe.none!, String.reverse(" 1 | "), []) -------------------------------------------------------------------------------- /src/Fm/highlight/end.fm: -------------------------------------------------------------------------------- 1 | Fm.highlight.end( 2 | col: Nat, 3 | row: Nat, 4 | res: List(String), 5 | ): String 6 | String.join("\n", res) -------------------------------------------------------------------------------- /src/Fm/mut.fm: -------------------------------------------------------------------------------- 1 | Fm.mut(name: Fm.Name, ini: A, fun: A -> A, map: Map(A)): Map(A) 2 | Map.mut(Fm.Name.to_bits(name), ini, fun, map) -------------------------------------------------------------------------------- /src/Fm/set.fm: -------------------------------------------------------------------------------- 1 | Fm.set(name: Fm.Name, val: A, map: Map(A)): Map(A) 2 | Map.set(Fm.Name.to_bits(name), val, map) -------------------------------------------------------------------------------- /src/Function.fm: -------------------------------------------------------------------------------- 1 | Function(A: Type, B: A -> Type): Type 2 | (x: A) -> B(x) -------------------------------------------------------------------------------- /src/Function/call.fm: -------------------------------------------------------------------------------- 1 | Function.call(x: A, f: A -> B): B 2 | f(x) -------------------------------------------------------------------------------- /src/Function/comp.fm: -------------------------------------------------------------------------------- 1 | Function.comp(g: B -> C, f: A -> B, x: A): C 2 | g(f(x)) -------------------------------------------------------------------------------- /src/Function/const.fm: -------------------------------------------------------------------------------- 1 | Function.const(x: A, y: B): A 2 | x -------------------------------------------------------------------------------- /src/Function/curry.fm: -------------------------------------------------------------------------------- 1 | Function.curry(f: Pair(A, B) -> C, x: A, y: B): C 2 | f(Pair.new(x, y)) -------------------------------------------------------------------------------- /src/Function/dcomp.fm: -------------------------------------------------------------------------------- 1 | Function.dcompType>(g:(b:B)->C(b), f:A -> B, x:A): C(f(x)) 2 | g(f(x)) -------------------------------------------------------------------------------- /src/Function/flip.fm: -------------------------------------------------------------------------------- 1 | Function.flip(f: A -> B -> C, y: B, x: A): C 2 | f(x, y) -------------------------------------------------------------------------------- /src/Function/id.fm: -------------------------------------------------------------------------------- 1 | Function.id(x: A): A 2 | x -------------------------------------------------------------------------------- /src/Function/pipe.fm: -------------------------------------------------------------------------------- 1 | Function.pipe(x: A, f: A -> B): B 2 | f(x) -------------------------------------------------------------------------------- /src/Function/uncurry.fm: -------------------------------------------------------------------------------- 1 | Function.uncurry(f: A -> B -> C, p: Pair(A, B)): C 2 | open p 3 | f(p.fst, p.snd) -------------------------------------------------------------------------------- /src/Functor.fm: -------------------------------------------------------------------------------- 1 | type Functor Type> { 2 | new(map: -> (A -> B) -> F(A) -> F(B)) 3 | } -------------------------------------------------------------------------------- /src/Functor/const.fm: -------------------------------------------------------------------------------- 1 | Functor.const Type>(f: Functor(F)): -> A -> F(B) -> F(A) 2 | (a) 3 | Functor.map!(f)!!(Function.const!!(a)) -------------------------------------------------------------------------------- /src/Functor/map.fm: -------------------------------------------------------------------------------- 1 | Functor.map Type>(f: Functor(F)): -> (A -> B) -> F(A) -> F(B) 2 | open f 3 | f.map -------------------------------------------------------------------------------- /src/GMap.fm: -------------------------------------------------------------------------------- 1 | type GMap { 2 | tip, 3 | bin(size: Nat, key: K, val: V, left: GMap(K,V), right: GMap(K,V)) 4 | } 5 | -------------------------------------------------------------------------------- /src/GMap/adjust.fm: -------------------------------------------------------------------------------- 1 | GMap.adjust( 2 | cmp : K -> K -> Cmp, 3 | f : V -> V, 4 | key : K, 5 | map : GMap(K,V) 6 | ) : GMap(K,V) 7 | GMap.adjust_with_key( 8 | cmp, 9 | (k, v) f(v), 10 | key, 11 | map 12 | ) -------------------------------------------------------------------------------- /src/GMap/foldr.fm: -------------------------------------------------------------------------------- 1 | GMap.foldr(f: V -> Z -> Z, z: Z, map : GMap(K,V)): Z 2 | GMap.foldr.go(f, z, map) -------------------------------------------------------------------------------- /src/GMap/foldr_with_key.fm: -------------------------------------------------------------------------------- 1 | GMap.foldr_with_key(f: K -> V -> Z -> Z, z: Z, map: GMap(K,V)): Z 2 | GMap.foldr_with_key.go(f, z, map) -------------------------------------------------------------------------------- /src/GMap/from_list.fm: -------------------------------------------------------------------------------- 1 | GMap.from_list( 2 | cmp : K -> K -> Cmp, 3 | xs : List(Pair(K,V)) 4 | ) : GMap(K,V) 5 | GMap.from_list.go(cmp, GMap.tip, xs) -------------------------------------------------------------------------------- /src/GMap/not_member.fm: -------------------------------------------------------------------------------- 1 | GMap.not_member(cmp: K -> K -> Cmp, key: K, map: GMap(K,V)): Bool 2 | Bool.not(GMap.member(cmp, key, map)) -------------------------------------------------------------------------------- /src/GMap/null.fm: -------------------------------------------------------------------------------- 1 | GMap.null(map: GMap(K,V)): Bool 2 | case map { 3 | tip: Bool.true, 4 | bin: Bool.false 5 | } -------------------------------------------------------------------------------- /src/GMap/singleton.fm: -------------------------------------------------------------------------------- 1 | GMap.singleton(key: K, val: V): GMap(K,V) 2 | GMap.bin(1, key, val, GMap.tip!!, GMap.tip!!) -------------------------------------------------------------------------------- /src/GMap/size.fm: -------------------------------------------------------------------------------- 1 | GMap.size(map: GMap(K,V)): Nat 2 | case map { 3 | tip: 0, 4 | bin: map.size 5 | } -------------------------------------------------------------------------------- /src/GMap/tests/1.fm: -------------------------------------------------------------------------------- 1 | GMap.tests.1 : IO(Unit) 2 | let kvs = [ 3 | Pair.new!!(1,"a") 4 | Pair.new!!(2,"b") 5 | Pair.new!!(3,"c") 6 | ] 7 | let map = GMap.from_list!!(Nat.cmp, kvs) 8 | let map = GMap.show!!(Nat.show, String.show, map) 9 | IO.print(map) -------------------------------------------------------------------------------- /src/GMap/to_list.fm: -------------------------------------------------------------------------------- 1 | GMap.to_list(map: GMap(K,V)): List(Pair(K,V)) 2 | GMap.foldr_with_key( 3 | (k, v, kvs) List.cons(Pair.new(k,v), kvs), 4 | List.nil, 5 | map 6 | ) -------------------------------------------------------------------------------- /src/GMap/w.fm: -------------------------------------------------------------------------------- 1 | GMap.w : Nat 2 | 3 -------------------------------------------------------------------------------- /src/GSet.fm: -------------------------------------------------------------------------------- 1 | type GSet { 2 | tip, 3 | bin(size: Nat, val: A, left: GSet(A), right: GSet(A)) 4 | } 5 | -------------------------------------------------------------------------------- /src/GSet/foldr.fm: -------------------------------------------------------------------------------- 1 | GSet.foldr(f: A -> B -> B, b: B, set: GSet(A)): B 2 | GSet.foldr.go!!(f, b, set) -------------------------------------------------------------------------------- /src/GSet/from_list.fm: -------------------------------------------------------------------------------- 1 | GSet.from_list(cmp: A -> A -> Cmp, xs: List(A)): GSet(A) 2 | List.foldr!!(GSet.tip!, GSet.insert!(cmp), xs) -------------------------------------------------------------------------------- /src/GSet/is_singleton.fm: -------------------------------------------------------------------------------- 1 | GSet.is_singleton(set: GSet(A)): Bool 2 | let size = GSet.size!(set) 3 | if Nat.eql(size, 1) then Bool.true else Bool.false -------------------------------------------------------------------------------- /src/GSet/members.fm: -------------------------------------------------------------------------------- 1 | GSet.members(set: GSet(A)): List(A) 2 | GSet.foldr!!(List.cons!, List.nil!, set) -------------------------------------------------------------------------------- /src/GSet/min.fm: -------------------------------------------------------------------------------- 1 | GSet.min(set: GSet(A)): Maybe(A) 2 | case set { 3 | tip: Maybe.none!, 4 | bin: case set.left { 5 | tip: Maybe.some!(set.val), 6 | bin: GSet.min!(set.left) 7 | } 8 | } -------------------------------------------------------------------------------- /src/GSet/node.fm: -------------------------------------------------------------------------------- 1 | GSet.node(val: A, left: GSet(A), right: GSet(A)): GSet(A) 2 | let size_left = GSet.size!(left) 3 | let size_right = GSet.size!(right) 4 | let new_size = List.sum([1, size_left, size_right]) 5 | GSet.bin!(new_size, val, left, right) -------------------------------------------------------------------------------- /src/GSet/not_member.fm: -------------------------------------------------------------------------------- 1 | GSet.not_member(cmp: A -> A -> Cmp, a: A, set: GSet(A)): Bool 2 | Bool.not(GSet.member!(cmp, a, set)) -------------------------------------------------------------------------------- /src/GSet/null.fm: -------------------------------------------------------------------------------- 1 | GSet.null(set: GSet(A)): Bool 2 | case set { 3 | tip: Bool.true, 4 | bin: Bool.false 5 | } -------------------------------------------------------------------------------- /src/GSet/show.fm: -------------------------------------------------------------------------------- 1 | GSet.show(to_str: A -> String, set: GSet(A)): String 2 | List.show!(to_str, GSet.members!(set)) -------------------------------------------------------------------------------- /src/GSet/singleton.fm: -------------------------------------------------------------------------------- 1 | GSet.singleton(a: A): GSet(A) 2 | GSet.bin!(1, a, GSet.tip!, GSet.tip!) -------------------------------------------------------------------------------- /src/GSet/size.fm: -------------------------------------------------------------------------------- 1 | GSet.size(set: GSet(A)): Nat 2 | case set { 3 | tip: 0, 4 | bin: set.size 5 | } -------------------------------------------------------------------------------- /src/GSet/to_list.fm: -------------------------------------------------------------------------------- 1 | GSet.to_list(set: GSet(A)): List(A) 2 | GSet.members!(set) -------------------------------------------------------------------------------- /src/GSet/w.fm: -------------------------------------------------------------------------------- 1 | GSet.w : Nat 2 | 3 -------------------------------------------------------------------------------- /src/IO.fm: -------------------------------------------------------------------------------- 1 | type IO { 2 | end(value: A), 3 | ask(query: String, param: String, then: (response: String) IO(A)), 4 | } -------------------------------------------------------------------------------- /src/IO/bind.fm: -------------------------------------------------------------------------------- 1 | IO.bind(a: IO(A), f: A -> IO(B)): IO(B) 2 | case a { 3 | end: f(a.value), 4 | ask: IO.ask(a.query, a.param, (x) IO.bind(a.then(x), f)), 5 | } -------------------------------------------------------------------------------- /src/IO/exit.fm: -------------------------------------------------------------------------------- 1 | IO.exit: IO(Unit) 2 | IO.ask("exit", "", (file) 3 | IO.end(Unit.new)) -------------------------------------------------------------------------------- /src/IO/get_args.fm: -------------------------------------------------------------------------------- 1 | IO.get_args: IO(String) 2 | IO.ask("get_args", "", (line) 3 | IO.end(line)) -------------------------------------------------------------------------------- /src/IO/get_file.fm: -------------------------------------------------------------------------------- 1 | IO.get_file(name: String): IO(String) 2 | IO.ask("get_file", name, (file) 3 | IO.end(file)) -------------------------------------------------------------------------------- /src/IO/get_line.fm: -------------------------------------------------------------------------------- 1 | IO.get_line: IO(String) 2 | IO.ask("get_line", "", (line) 3 | IO.end(line)) -------------------------------------------------------------------------------- /src/IO/monad.fm: -------------------------------------------------------------------------------- 1 | IO.monad: Monad(IO) 2 | Monad.new(IO.bind, IO.end) -------------------------------------------------------------------------------- /src/IO/print.fm: -------------------------------------------------------------------------------- 1 | IO.print(text: String): IO(Unit) 2 | IO.put_string(text | "\n") 3 | -------------------------------------------------------------------------------- /src/IO/prompt.fm: -------------------------------------------------------------------------------- 1 | IO.prompt(text: String): IO(String) 2 | do IO { 3 | IO.put_string(text) 4 | IO.get_line 5 | } 6 | -------------------------------------------------------------------------------- /src/IO/purify.fm: -------------------------------------------------------------------------------- 1 | IO.purify(io: IO(A)): A 2 | case io { 3 | end: io.value, 4 | ask: IO.purify(io.then("")), 5 | } -------------------------------------------------------------------------------- /src/IO/put_string.fm: -------------------------------------------------------------------------------- 1 | IO.put_string(text: String): IO(Unit) 2 | IO.ask("put_string", text, (skip) 3 | IO.end(Unit.new)) 4 | -------------------------------------------------------------------------------- /src/IO/set_file.fm: -------------------------------------------------------------------------------- 1 | IO.set_file(name: String, content: String): IO(Unit) 2 | IO.ask("set_file", name | "=" | content, (ok) 3 | IO.end(Unit.new)) -------------------------------------------------------------------------------- /src/Image3D.fm: -------------------------------------------------------------------------------- 1 | type Image3D { 2 | new(length: U32, capacity: U32, buffer: Buffer32) 3 | } 4 | -------------------------------------------------------------------------------- /src/Image3D/alloc_capacity.fm: -------------------------------------------------------------------------------- 1 | Image3D.alloc_capacity(capacity: U32): Image3D 2 | let buffer = Buffer32.alloc(U32.needed_depth(U32.mul(Nat.to_u32(2),capacity))) 3 | Image3D.new(0u, capacity, buffer) 4 | -------------------------------------------------------------------------------- /src/Image3D/clear.fm: -------------------------------------------------------------------------------- 1 | Image3D.clear(img: Image3D): Image3D 2 | Image3D.set_length(0u, img) 3 | -------------------------------------------------------------------------------- /src/Image3D/empty.fm: -------------------------------------------------------------------------------- 1 | Image3D.empty: Image3D 2 | Image3D.alloc_capacity(Nat.to_u32(100)) -------------------------------------------------------------------------------- /src/Image3D/get_capacity.fm: -------------------------------------------------------------------------------- 1 | Image3D.get_capacity(img: Image3D): U32 2 | open img 3 | img.capacity -------------------------------------------------------------------------------- /src/Image3D/get_col.fm: -------------------------------------------------------------------------------- 1 | Image3D.get_col(idx: U32, vox: Image3D): U32 2 | case vox { 3 | new: Buffer32.get(U32.add(U32.mul(idx,2u),1u), vox.buffer) 4 | } 5 | -------------------------------------------------------------------------------- /src/Image3D/get_length.fm: -------------------------------------------------------------------------------- 1 | Image3D.get_length(img: Image3D): U32 2 | open img 3 | img.length -------------------------------------------------------------------------------- /src/Image3D/parse_byte.fm: -------------------------------------------------------------------------------- 1 | Image3D.parse_byte(idx: U32, voxdata: String): U32 2 | let chr = U32.slice(U32.mul(idx,2u), U32.add(U32.mul(idx,2u),2u), voxdata) 3 | U32.read_base(16u, chr) 4 | -------------------------------------------------------------------------------- /src/Image3D/set.fm: -------------------------------------------------------------------------------- 1 | // Sets position and color of the idx voxel of an Image3D 2 | Image3D.set(idx: U32, pos: U32, col: U32, img: Image3D): Image3D 3 | let img = Image3D.set_pos(idx, pos, img) 4 | let img = Image3D.set_col(idx, col, img) 5 | img 6 | -------------------------------------------------------------------------------- /src/Image3D/set_length.fm: -------------------------------------------------------------------------------- 1 | Image3D.set_length(length: U32, img: Image3D): Image3D 2 | open img 3 | Image3D.new(length, img.capacity, img.buffer) -------------------------------------------------------------------------------- /src/Int.fm: -------------------------------------------------------------------------------- 1 | Int: Type 2 | int Type> -> 3 | (new: (x: Nat) -> (y: Nat) -> P(Int.new(x, y))) -> 4 | P(int) 5 | -------------------------------------------------------------------------------- /src/Int/0.fm: -------------------------------------------------------------------------------- 1 | Int.0: Int 2 | Int.from_nat(0) -------------------------------------------------------------------------------- /src/Int/1.fm: -------------------------------------------------------------------------------- 1 | Int.1: Int 2 | Int.from_nat(1) -------------------------------------------------------------------------------- /src/Int/add.fm: -------------------------------------------------------------------------------- 1 | Int.add(a: Int, b: Int): Int 2 | open a 3 | open b 4 | Int.new(Nat.add(a.x, b.x), Nat.add(a.y, b.y)) -------------------------------------------------------------------------------- /src/Int/cmp.fm: -------------------------------------------------------------------------------- 1 | Int.cmp(a: Int, b: Int): Cmp 2 | open a 3 | open b 4 | Nat.cmp(Nat.add(a.x, b.y), Nat.add(b.x, a.y)) 5 | -------------------------------------------------------------------------------- /src/Int/div_nat.fm: -------------------------------------------------------------------------------- 1 | Int.div_nat(a: Int, n: Nat): Int 2 | open a 3 | Int.new(Nat.div(a.x, n), Nat.div(a.y, n)) 4 | -------------------------------------------------------------------------------- /src/Int/eql.fm: -------------------------------------------------------------------------------- 1 | Int.eql(a: Int, b: Int): Bool 2 | case Int.cmp(a, b) { 3 | ltn: Bool.false, 4 | eql: Bool.true, 5 | gtn: Bool.false, 6 | } 7 | -------------------------------------------------------------------------------- /src/Int/from_nat.fm: -------------------------------------------------------------------------------- 1 | Int.from_nat(n: Nat): Int 2 | Int.new(n, 0) -------------------------------------------------------------------------------- /src/Int/mod_nat.fm: -------------------------------------------------------------------------------- 1 | Int.mod_nat(a: Int, n: Nat): Nat 2 | open a 3 | let b = Nat.mod(a.y, n) 4 | let sum = Nat.add(a.x, Nat.sub(n, b)) 5 | Nat.mod(sum, n) -------------------------------------------------------------------------------- /src/Int/mul.fm: -------------------------------------------------------------------------------- 1 | Int.mul(a: Int, b: Int): Int 2 | open a 3 | open b 4 | Int.new(Nat.add(Nat.mul(a.x, b.x), Nat.mul(a.y, b.y)), Nat.add(Nat.mul(a.x, b.y), Nat.mul(a.y, b.x))) -------------------------------------------------------------------------------- /src/Int/neg.fm: -------------------------------------------------------------------------------- 1 | Int.neg(a: Int): Int 2 | open a 3 | Int.new(a.y, a.x) -------------------------------------------------------------------------------- /src/Int/sub.fm: -------------------------------------------------------------------------------- 1 | Int.sub(a: Int, b: Int): Int 2 | Int.add(a, Int.neg(b)) -------------------------------------------------------------------------------- /src/Int/to_nat.fm: -------------------------------------------------------------------------------- 1 | Int.to_nat(a: Int): Pair(Bool, Nat) 2 | open a 3 | case a.y { 4 | zero: Pair.new!!(Bool.false, a.x), 5 | succ: Pair.new!!(Bool.true, a.y), 6 | } -------------------------------------------------------------------------------- /src/Int/to_string_base.fm: -------------------------------------------------------------------------------- 1 | Int.to_string_base(base: Nat, a: Int): String 2 | open a 3 | case a.y { 4 | zero: Nat.to_string_base(base, a.x), 5 | succ: String.cons('-', Nat.to_string_base(base, a.y)), 6 | } -------------------------------------------------------------------------------- /src/JSON.fm: -------------------------------------------------------------------------------- 1 | type JSON { 2 | null, 3 | bool(x: Bool), 4 | number(x: F64), 5 | string(x: String), 6 | array(x: List(JSON)), 7 | object(x: List(Pair(String, JSON))) 8 | } -------------------------------------------------------------------------------- /src/List.fm: -------------------------------------------------------------------------------- 1 | type List { 2 | nil, 3 | cons(head: A, tail: List(A)), 4 | } -------------------------------------------------------------------------------- /src/List/Builder.fm: -------------------------------------------------------------------------------- 1 | List.Builder(A: Type): Type 2 | List(A) -> List(A) -------------------------------------------------------------------------------- /src/List/Builder/concat.fm: -------------------------------------------------------------------------------- 1 | List.Builder.concat(a: List.Builder(A), b: List.Builder(A)): List.Builder(A) 2 | (x) a(b(x)) -------------------------------------------------------------------------------- /src/List/Builder/cons.fm: -------------------------------------------------------------------------------- 1 | List.Builder.cons(c: A, lb: List.Builder(A)) : List.Builder(A) 2 | (x) List.cons!(c,lb(x)) -------------------------------------------------------------------------------- /src/List/Builder/new.fm: -------------------------------------------------------------------------------- 1 | List.Builder.new : List.Builder(A) 2 | (x) x -------------------------------------------------------------------------------- /src/List/Builder/snoc.fm: -------------------------------------------------------------------------------- 1 | List.Builder.snoc(c: A, lb: List.Builder(A)) : List.Builder(A) 2 | (x) lb(List.cons!(c,x)) -------------------------------------------------------------------------------- /src/List/all.fm: -------------------------------------------------------------------------------- 1 | List.all(cond: A -> Bool, list: List(A)): Bool 2 | case list{ 3 | nil : Bool.true 4 | cons: case cond(list.head){ 5 | true : List.all!(cond, list.tail) 6 | false: Bool.false 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/and.fm: -------------------------------------------------------------------------------- 1 | List.and(list: List(Bool)): Bool 2 | List.all!((x) x, list) -------------------------------------------------------------------------------- /src/List/any.fm: -------------------------------------------------------------------------------- 1 | List.any(cond: A -> Bool, list: List(A)): Bool 2 | case list{ 3 | nil : Bool.false 4 | cons: case cond(list.head){ 5 | true : Bool.true 6 | false: List.any!(cond, list.tail) 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/append.fm: -------------------------------------------------------------------------------- 1 | List.append(as: List(A), a: A): List(A) 2 | case as{ 3 | nil : List.pure!(a) 4 | cons: List.cons!(as.head,List.append!(as.tail, a)) 5 | } -------------------------------------------------------------------------------- /src/List/at.fm: -------------------------------------------------------------------------------- 1 | List.at(index: Nat, list: List(A)): Maybe(A) 2 | case list { 3 | nil: Maybe.none!, 4 | cons: case index { 5 | zero: Maybe.some!(list.head), 6 | succ: List.at!(index.pred, list.tail), 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/at_last.fm: -------------------------------------------------------------------------------- 1 | List.at_last(index: Nat, list: List(A)): Maybe(A) 2 | List.at(index, List.reverse!(list)) -------------------------------------------------------------------------------- /src/List/bind.fm: -------------------------------------------------------------------------------- 1 | List.bind(xs: List(A), f: A -> List(B)): List(B) 2 | List.flatten!(List.map!!(f, xs)) -------------------------------------------------------------------------------- /src/List/chunks_of.fm: -------------------------------------------------------------------------------- 1 | List.chunks_of(len: Nat, xs: List(A)): List(List(A)) 2 | List.chunks_of.go!(len, xs, len, List.nil!) -------------------------------------------------------------------------------- /src/List/concat.fm: -------------------------------------------------------------------------------- 1 | List.concat(as: List(A), bs: List(A)): List(A) 2 | case as { 3 | nil: bs, 4 | cons: List.cons!(as.head, List.concat!(as.tail,bs)) 5 | } -------------------------------------------------------------------------------- /src/List/delete_at.fm: -------------------------------------------------------------------------------- 1 | List.delete_at(idx: Nat, list: List(A)): List(A) 2 | case idx{ 3 | zero: List.tail(list) 4 | succ: case list{ 5 | nil : list 6 | cons: List.cons(list.head, List.delete_at(idx.pred, list.tail)) 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/drop.fm: -------------------------------------------------------------------------------- 1 | List.drop(n: Nat, xs: List(A)): List(A) 2 | case n{ 3 | zero: xs 4 | succ: case xs{ 5 | nil: List.nil! 6 | cons: List.drop!(n.pred,xs.tail) 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/drop_while.fm: -------------------------------------------------------------------------------- 1 | List.drop_while(f: A -> Bool, xs: List(A)): List(A) 2 | case xs{ 3 | nil : List.nil! 4 | cons: case f(xs.head){ 5 | true : List.drop_while!(f,xs.tail) 6 | false: xs 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/elem.fm: -------------------------------------------------------------------------------- 1 | List.elem(p: A -> A -> Bool, a: A, as: List(A)): Bool 2 | case as { 3 | nil : Bool.false, 4 | cons: case p(a, as.head) { 5 | true : Bool.true, 6 | false: List.elem(p, a, as.tail) 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/filter.fm: -------------------------------------------------------------------------------- 1 | List.filter(f: A -> Bool, xs: List(A)): List(A) 2 | case xs{ 3 | nil : List.nil! 4 | cons: case f(xs.head){ 5 | true : List.cons!(xs.head,List.filter!(f, xs.tail)) 6 | false: List.filter!(f, xs.tail) 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/find.fm: -------------------------------------------------------------------------------- 1 | List.find(cond: A -> Bool, xs: List(A)): Maybe(A) 2 | case xs{ 3 | nil : Maybe.none! 4 | cons: case cond(xs.head){ 5 | true : Maybe.some!(xs.head) 6 | false: List.find!(cond, xs.tail) 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/find_last.fm: -------------------------------------------------------------------------------- 1 | List.find_last(xs: List(A), f: A -> Nat -> Bool): Maybe(Pair(A)(Nat)) 2 | List.find_last.go(xs,f,Nat.zero,Maybe.none!) -------------------------------------------------------------------------------- /src/List/flatten.fm: -------------------------------------------------------------------------------- 1 | List.flatten(xs: List(List(A))): List(A) 2 | case xs { 3 | nil: List.nil!, 4 | cons: List.concat!(xs.head, List.flatten!(xs.tail)) 5 | } -------------------------------------------------------------------------------- /src/List/fold.fm: -------------------------------------------------------------------------------- 1 | List.fold(list: List(A)): -> P -> (A -> P -> P) -> P 2 |

(nil, cons) 3 | case list { 4 | nil : nil, 5 | cons: cons(list.head, List.fold(list.tail)

(nil, cons)) 6 | } 7 | -------------------------------------------------------------------------------- /src/List/foldr.fm: -------------------------------------------------------------------------------- 1 | List.foldr(b: B, f: A -> B -> B, xs: List(A)): B 2 | List.fold(xs)(b,f) 3 | -------------------------------------------------------------------------------- /src/List/for.fm: -------------------------------------------------------------------------------- 1 | List.for(xs: List(A))(b: B, f: A -> B -> B): B 2 | case xs { 3 | nil : b, 4 | cons: List.for(xs.tail)(f(xs.head,b),f) 5 | } 6 | -------------------------------------------------------------------------------- /src/List/head.fm: -------------------------------------------------------------------------------- 1 | List.head(xs: List(A)): Maybe(A) 2 | case xs { 3 | nil : Maybe.none!, 4 | cons: Maybe.some!(xs.head) 5 | } 6 | -------------------------------------------------------------------------------- /src/List/head_with_default.fm: -------------------------------------------------------------------------------- 1 | List.head_with_default(default: A, xs: List(A)): A 2 | case xs { 3 | nil : default, 4 | cons: xs.head 5 | } 6 | -------------------------------------------------------------------------------- /src/List/ifind.fm: -------------------------------------------------------------------------------- 1 | List.ifind(xs: List(A), f: A -> Nat -> Bool): Maybe(Pair(A,Nat)) 2 | List.ifind.go(xs,f,Nat.zero) 3 | -------------------------------------------------------------------------------- /src/List/imap.fm: -------------------------------------------------------------------------------- 1 | List.imap(f: Nat -> A -> B, xs: List(A)): List(B) 2 | case xs { 3 | nil : List.nil!, 4 | cons: List.cons!(f(0,xs.head),List.imap!!((n) f(Nat.succ(n)),xs.tail)) 5 | } -------------------------------------------------------------------------------- /src/List/indices.fm: -------------------------------------------------------------------------------- 1 | List.indices(xs: List(A)): List(Pair(Nat,A)) 2 | List.imap((i,x) {i,x}, xs) -------------------------------------------------------------------------------- /src/List/indices/u32.fm: -------------------------------------------------------------------------------- 1 | List.indices.u32(xs: List(A)): List(Pair(U32,A)) 2 | List.imap((i,x) {Nat.to_u32(i),x}, xs) -------------------------------------------------------------------------------- /src/List/init.fm: -------------------------------------------------------------------------------- 1 | List.init(list: List(A)): List(A) 2 | case list { 3 | cons: case list.tail { 4 | cons: List.cons!(list.head, List.init(list.tail)), 5 | nil: List.nil!, 6 | }, 7 | nil: List.nil!, 8 | } -------------------------------------------------------------------------------- /src/List/insert_sort_nat.fm: -------------------------------------------------------------------------------- 1 | List.insert_sort_nat(ns: List(Nat)): List(Nat) 2 | List.foldr!!(List.nil!, List.insert_sort_nat.aux, ns) -------------------------------------------------------------------------------- /src/List/insert_sort_nat/aux.fm: -------------------------------------------------------------------------------- 1 | List.insert_sort_nat.aux(n: Nat, ns: List(Nat)): List(Nat) 2 | open List.span!(Nat.lte(n), ns) as spanned 3 | List.concat!(spanned.fst, List.cons!(n, spanned.snd)) -------------------------------------------------------------------------------- /src/List/intercalate.fm: -------------------------------------------------------------------------------- 1 | List.intercalate(sep: List(A), xs: List(List(A))): List(A) 2 | List.flatten(List.intersperse(sep,xs)) -------------------------------------------------------------------------------- /src/List/is_empty.fm: -------------------------------------------------------------------------------- 1 | List.is_empty(list: List(A)): Bool 2 | case list { 3 | nil: Bool.true, 4 | cons: Bool.false, 5 | } -------------------------------------------------------------------------------- /src/List/length.fm: -------------------------------------------------------------------------------- 1 | List.length(xs: List(A)): Nat 2 | case xs { 3 | nil: 0, 4 | cons: Nat.succ(List.length(xs.tail)), 5 | } 6 | -------------------------------------------------------------------------------- /src/List/map.fm: -------------------------------------------------------------------------------- 1 | List.map(f: A -> B, as: List(A)): List(B) 2 | case as { 3 | nil: List.nil!, 4 | cons: List.cons!(f(as.head), List.map!!(f,as.tail)), 5 | } -------------------------------------------------------------------------------- /src/List/mapped.fm: -------------------------------------------------------------------------------- 1 | List.mapped(as: List(A))(f: A -> B): List(B) 2 | case as { 3 | nil: List.nil!, 4 | cons: List.cons!(f(as.head),List.mapped(as.tail)(f)) 5 | } -------------------------------------------------------------------------------- /src/List/monad.fm: -------------------------------------------------------------------------------- 1 | List.monad: Monad(List) 2 | Monad.new(List.bind, List.pure) 3 | -------------------------------------------------------------------------------- /src/List/null.fm: -------------------------------------------------------------------------------- 1 | List.null(xs: List(A)) : Bool 2 | case xs { 3 | nil : Bool.true, 4 | cons: Bool.false 5 | } 6 | -------------------------------------------------------------------------------- /src/List/or.fm: -------------------------------------------------------------------------------- 1 | List.or(list: List(Bool)): Bool 2 | List.any!((x) x)(list) 3 | -------------------------------------------------------------------------------- /src/List/product.fm: -------------------------------------------------------------------------------- 1 | List.product(xs: List(Nat)) : Nat 2 | List.product.go(xs, Nat.zero) 3 | -------------------------------------------------------------------------------- /src/List/product/go.fm: -------------------------------------------------------------------------------- 1 | List.product.go(xs: List(Nat), n: Nat) : Nat 2 | case xs { 3 | nil : Nat.zero, 4 | cons: List.product.go(xs.tail,Nat.mul(xs.head,n)) 5 | } -------------------------------------------------------------------------------- /src/List/pure.fm: -------------------------------------------------------------------------------- 1 | List.pure(x : A) : List(A) 2 | List.cons(x)(List.nil) 3 | -------------------------------------------------------------------------------- /src/List/range.fm: -------------------------------------------------------------------------------- 1 | List.range(n: Nat): List(Nat) 2 | List.range.go(n, List.nil!) 3 | -------------------------------------------------------------------------------- /src/List/range/go.fm: -------------------------------------------------------------------------------- 1 | List.range.go(n: Nat, xs: List(Nat)): List(Nat) 2 | case n { 3 | zero: xs, 4 | succ: List.range.go(n.pred, List.cons!(n, xs)) 5 | } -------------------------------------------------------------------------------- /src/List/range/nat.fm: -------------------------------------------------------------------------------- 1 | List.range.nat(nat: Nat): List(Nat) 2 | List.range.nat.go(nat, List.nil!) -------------------------------------------------------------------------------- /src/List/range/nat/go.fm: -------------------------------------------------------------------------------- 1 | List.range.nat.go(nat: Nat, list: List(Nat)): List(Nat) 2 | case nat { 3 | zero: list, 4 | succ: List.range.nat.go(nat.pred, List.cons!(nat.pred, list)), 5 | } -------------------------------------------------------------------------------- /src/List/reverse.fm: -------------------------------------------------------------------------------- 1 | List.reverse(xs: List(A)) : List(A) 2 | List.reverse.go!(xs,List.nil!) 3 | -------------------------------------------------------------------------------- /src/List/reverse/go.fm: -------------------------------------------------------------------------------- 1 | List.reverse.go(xs: List(A), res: List(A)): List(A) 2 | case xs { 3 | nil: res, 4 | cons: List.reverse.go!(xs.tail,List.cons!(xs.head,res)) 5 | } -------------------------------------------------------------------------------- /src/List/run_builder.fm: -------------------------------------------------------------------------------- 1 | List.run_builder(lb: List.Builder(A)): List(A) 2 | lb(List.nil!) 3 | -------------------------------------------------------------------------------- /src/List/show.fm: -------------------------------------------------------------------------------- 1 | List.show(f: A -> String, xs: List(A)): String 2 | String.flatten(["[",String.intercalate(",", List.map!!(f,xs)),"]"]) 3 | -------------------------------------------------------------------------------- /src/List/sum.fm: -------------------------------------------------------------------------------- 1 | List.sum(xs: List(Nat)) : Nat 2 | List.sum.go(xs, Nat.zero) 3 | -------------------------------------------------------------------------------- /src/List/sum/go.fm: -------------------------------------------------------------------------------- 1 | List.sum.go(xs: List(Nat), n: Nat) : Nat 2 | case xs { 3 | nil : n, 4 | cons: List.sum.go(xs.tail,Nat.add(xs.head,n)) 5 | } -------------------------------------------------------------------------------- /src/List/tail.fm: -------------------------------------------------------------------------------- 1 | List.tail(xs: List(A)): List(A) 2 | case xs { 3 | nil: List.nil!, 4 | cons: xs.tail, 5 | } 6 | -------------------------------------------------------------------------------- /src/List/take.fm: -------------------------------------------------------------------------------- 1 | List.take(n: Nat, xs: List(A)): List(A) 2 | case xs { 3 | nil : List.nil!, 4 | cons: case n { 5 | zero: List.nil!, 6 | succ: List.cons!(xs.head,List.take!(n.pred, xs.tail)) 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/List/take_while.fm: -------------------------------------------------------------------------------- 1 | List.take_while(f: A -> Bool, xs: List(A)) : List(A) 2 | case xs{ 3 | nil : List.nil! 4 | cons: case f(xs.head){ 5 | true : List.cons!(xs.head,List.take_while!(f, xs.tail)) 6 | false: List.nil! 7 | } 8 | } -------------------------------------------------------------------------------- /src/List/to_builder.fm: -------------------------------------------------------------------------------- 1 | List.to_builder(list: List(A)) : List.Builder(A) 2 | List.to_builder.go!(list, List.Builder.new!) -------------------------------------------------------------------------------- /src/List/to_builder/go.fm: -------------------------------------------------------------------------------- 1 | List.to_builder.go(list: List(A), lb: List.Builder(A)) : List.Builder(A) 2 | case list { 3 | nil : lb, 4 | cons: List.to_builder.go!(list.tail, List.Builder.snoc!(list.head, lb)) 5 | } -------------------------------------------------------------------------------- /src/List/uncons.fm: -------------------------------------------------------------------------------- 1 | List.uncons(xs: List(A)): Maybe(Pair(A,List(A))) 2 | case xs { 3 | nil : Maybe.none!, 4 | cons: Maybe.some!(Pair.new!!(xs.head,xs.tail)) 5 | } -------------------------------------------------------------------------------- /src/List/unfoldr.fm: -------------------------------------------------------------------------------- 1 | List.unfoldr(f: A -> Maybe(Pair(A,B)), a: A): List(B) 2 | List.unfoldr.go(f, a, List.nil) 3 | -------------------------------------------------------------------------------- /src/List/zip.fm: -------------------------------------------------------------------------------- 1 | List.zip(as: List(A), bs: List(B)): List(Pair(A,B)) 2 | case as { 3 | nil: List.nil!, 4 | cons: case bs { 5 | nil: List.nil!, 6 | cons: List.cons!(Pair.new!!(as.head, bs.head), List.zip(as.tail, bs.tail)), 7 | } 8 | } -------------------------------------------------------------------------------- /src/Main.fm: -------------------------------------------------------------------------------- 1 | Main: IO(Unit) 2 | do IO { 3 | IO.print("Hello, world!") 4 | 5 | var name = IO.prompt("What is your name? ") 6 | 7 | IO.print("Hello, " | name | "!") 8 | } 9 | -------------------------------------------------------------------------------- /src/Map.fm: -------------------------------------------------------------------------------- 1 | type Map { 2 | new, 3 | tie(val: Maybe(A), lft: Map(A), rgt: Map(A)), 4 | } -------------------------------------------------------------------------------- /src/Map/Row.fm: -------------------------------------------------------------------------------- 1 | Map.Row(A : Type,key: Bits, x: A, xs: Map(A)) : Type 2 | case Map.get(key,xs) as v { 3 | none: Empty, 4 | some: Equal(A,x,v.value) 5 | } -------------------------------------------------------------------------------- /src/Map/from_list.fm: -------------------------------------------------------------------------------- 1 | Map.from_list(xs: List(Pair(Bits,A))): Map(A) 2 | case xs { 3 | nil : Map.new!, 4 | cons: case xs.head as p { 5 | new: Map.set!(p.fst, p.snd, Map.from_list!(xs.tail)) 6 | } 7 | } -------------------------------------------------------------------------------- /src/Map/keys.fm: -------------------------------------------------------------------------------- 1 | Map.keys(xs: Map(A)): List(Bits) 2 | List.reverse!(Map.keys.go!(xs, Bits.e, List.nil!)) -------------------------------------------------------------------------------- /src/Map/merge.fm: -------------------------------------------------------------------------------- 1 | Map.merge( 2 | a_not_b : Bits -> A -> Maybe(C), 3 | b_not_a : Bits -> B -> Maybe(C), 4 | a_and_b : Bits -> A -> B -> Maybe(C), 5 | a: Map(A), 6 | b: Map(B) 7 | ) : Map(C) 8 | Map.merge.go!!!(a_not_b,b_not_a,a_and_b,Bits.e,a,b) -------------------------------------------------------------------------------- /src/Map/to_list.fm: -------------------------------------------------------------------------------- 1 | Map.to_list(xs: Map(A)): List(Pair(Bits,A)) 2 | List.reverse!(Map.to_list.go!(xs, Bits.e, List.nil!)) -------------------------------------------------------------------------------- /src/Map/values.fm: -------------------------------------------------------------------------------- 1 | Map.values(xs: Map(A)): List(A) 2 | Map.values.go(xs, List.nil!) -------------------------------------------------------------------------------- /src/Maybe.fm: -------------------------------------------------------------------------------- 1 | type Maybe { 2 | none, 3 | some(value: A), 4 | } -------------------------------------------------------------------------------- /src/Maybe/IsSome.fm: -------------------------------------------------------------------------------- 1 | Maybe.IsSome(A: Type,x: Maybe(A)): Type 2 | case x{ 3 | none: Empty 4 | some: A 5 | } -------------------------------------------------------------------------------- /src/Maybe/bind.fm: -------------------------------------------------------------------------------- 1 | Maybe.bind(m: Maybe(A), f: A -> Maybe(B)): Maybe(B) 2 | case m { 3 | none: Maybe.none, 4 | some: f(m.value), 5 | } -------------------------------------------------------------------------------- /src/Maybe/default.fm: -------------------------------------------------------------------------------- 1 | Maybe.default(a: A, m: Maybe(A)): A 2 | case m { 3 | none: a, 4 | some: m.value, 5 | } -------------------------------------------------------------------------------- /src/Maybe/extract.fm: -------------------------------------------------------------------------------- 1 | Maybe.extract(m: Maybe(A))(a: B, f: A -> B): B 2 | case m { 3 | none: a, 4 | some: f(m.value), 5 | } -------------------------------------------------------------------------------- /src/Maybe/functor.fm: -------------------------------------------------------------------------------- 1 | Maybe.functor: Functor(Maybe) 2 | Functor.new(Maybe.map) -------------------------------------------------------------------------------- /src/Maybe/join.fm: -------------------------------------------------------------------------------- 1 | Maybe.join(m: Maybe(Maybe(A))): Maybe(A) 2 | case m{ 3 | none: Maybe.none 4 | some: m.value 5 | } -------------------------------------------------------------------------------- /src/Maybe/map.fm: -------------------------------------------------------------------------------- 1 | Maybe.map(f: A -> B, m: Maybe(A)): Maybe(B) 2 | case m { 3 | none: Maybe.none, 4 | some: Maybe.some(f(m.value)), 5 | } -------------------------------------------------------------------------------- /src/Maybe/mapped.fm: -------------------------------------------------------------------------------- 1 | Maybe.mapped(m: Maybe(A))(f: A -> B): Maybe(B) 2 | case m { 3 | none: Maybe.none, 4 | some: Maybe.some(f(m.value)), 5 | } -------------------------------------------------------------------------------- /src/Maybe/monad.fm: -------------------------------------------------------------------------------- 1 | Maybe.monad: Monad(Maybe) 2 | Monad.new(Maybe.bind, Maybe.some) -------------------------------------------------------------------------------- /src/Maybe/or.fm: -------------------------------------------------------------------------------- 1 | Maybe.or(a: Maybe(A), b: Maybe(A)): Maybe(A) 2 | case a { 3 | none: b, 4 | some: Maybe.some!(a.value), 5 | } -------------------------------------------------------------------------------- /src/Maybe/pure.fm: -------------------------------------------------------------------------------- 1 | Maybe.pure(a: A): Maybe(A) 2 | Maybe.some(a) -------------------------------------------------------------------------------- /src/Maybe/to_bool.fm: -------------------------------------------------------------------------------- 1 | Maybe.to_bool(m: Maybe(A)): Bool 2 | case m { 3 | none: Bool.false, 4 | some: Bool.true, 5 | } -------------------------------------------------------------------------------- /src/Monad.fm: -------------------------------------------------------------------------------- 1 | type Monad Type> { 2 | new( 3 | bind: (m: M(A)) (f: (x:A) M(B)) M(B), 4 | pure: (x: A) M(A), 5 | ) 6 | } -------------------------------------------------------------------------------- /src/Monad/bind.fm: -------------------------------------------------------------------------------- 1 | Monad.bind Type>(m: Monad(M)): -> M(A) -> (A -> M(B)) -> M(B) 2 | case m { 3 | new: m.bind 4 | } -------------------------------------------------------------------------------- /src/Monad/pure.fm: -------------------------------------------------------------------------------- 1 | Monad.pure Type>(m: Monad(M)): -> A -> M(A) 2 | case m { 3 | new: m.pure 4 | } -------------------------------------------------------------------------------- /src/Mons/Action.fm: -------------------------------------------------------------------------------- 1 | type Mons.Action{ 2 | Mons.Action.walk(dir: Mons.Dir) 3 | } -------------------------------------------------------------------------------- /src/Mons/Attr/new_hero.fm: -------------------------------------------------------------------------------- 1 | Mons.Attr.new_hero: Mons.Attr 2 | Mons.Attr.new_neutral([Image3D.empty]) -------------------------------------------------------------------------------- /src/Mons/Attr/new_mage.fm: -------------------------------------------------------------------------------- 1 | Mons.Attr.new_mage: Mons.Attr 2 | Mons.Attr.new_neutral([Image3D.empty]) -------------------------------------------------------------------------------- /src/Mons/Dir.fm: -------------------------------------------------------------------------------- 1 | type Mons.Dir { 2 | right, 3 | up, 4 | left, 5 | down 6 | } -------------------------------------------------------------------------------- /src/Mons/Effect/clear.fm: -------------------------------------------------------------------------------- 1 | Mons.Effect.clear: Mons.Effect 2 | let clean = {u0, Bool.false} 3 | let clean_bool = {Bool.false, Bool.false} 4 | Mons.Effect.new(clean, u0, clean, clean, clean_bool, u0, 5 | Bool.false, Bool.false) -------------------------------------------------------------------------------- /src/Mons/Game.fm: -------------------------------------------------------------------------------- 1 | type Mons.Game { 2 | new( 3 | usr: Word(160), // player name 4 | pos: Map(Pos32), // players positions 5 | map: Mons.Map, // the game map 6 | stt: Mons.Screen, // the current state of the game 7 | tik: U32 8 | ) 9 | } 10 | -------------------------------------------------------------------------------- /src/Mons/Game/get_hero_pos.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.get_hero_pos(game: Mons.Game): Maybe(Pos32) 2 | open game 3 | Mons.Game.get_user_pos(game.usr, game) -------------------------------------------------------------------------------- /src/Mons/Game/get_skills_at.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.get_skills_at(idx: Nat, obj: Mons.Object): Mons.Skill 2 | open obj 3 | let skills = Mons.Kind.get_skills(obj.kin) 4 | case List.at!(idx, skills) as skill { 5 | none: Mons.Skill.none, 6 | some: skill.value 7 | } -------------------------------------------------------------------------------- /src/Mons/Game/get_tile.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.get_tile(pos: Pos32, game: Mons.Game): List(Mons.Object) 2 | open game 3 | Mons.Map.get_list(pos, game.map) -------------------------------------------------------------------------------- /src/Mons/Game/get_user_pos.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.get_user_pos(user: Word(160), game: Mons.Game): Maybe(Pos32) 2 | open game 3 | Map.get!(Word.to_bits<160>(user), game.pos) -------------------------------------------------------------------------------- /src/Mons/Game/get_usr.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.get_usr(game: Mons.Game): Word(160) 2 | open game 3 | game.usr -------------------------------------------------------------------------------- /src/Mons/Game/set_map.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.set_map(map: Mons.Map, game: Mons.Game): Mons.Game 2 | open game 3 | Mons.Game.new(game.usr, game.pos, map, game.stt, game.tik) -------------------------------------------------------------------------------- /src/Mons/Game/set_stt.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.set_stt(stt: Mons.Screen, game: Mons.Game): Mons.Game 2 | open game 3 | Mons.Game.new(game.usr, game.pos, game.map, stt, game.tik) -------------------------------------------------------------------------------- /src/Mons/Game/set_tik.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.set_tik(tik: U32, game: Mons.Game): Mons.Game 2 | open game 3 | Mons.Game.new(game.usr, game.pos, game.map, game.stt, tik) -------------------------------------------------------------------------------- /src/Mons/Game/set_user_pos.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.set_user_pos(user: Word(160), pos: Pos32, game: Mons.Game): Mons.Game 2 | open game 3 | Mons.Game.new(game.usr, Map.set!(Word.to_bits<160>(user), pos, game.pos), 4 | game.map, game.stt, game.tik) -------------------------------------------------------------------------------- /src/Mons/Game/set_usr.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.set_usr(usr: Word(160), game: Mons.Game): Mons.Game 2 | open game 3 | Mons.Game.new(usr, game.pos, game.map, game.stt, game.tik) -------------------------------------------------------------------------------- /src/Mons/Game/update.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.update(fn: Mons.Object -> Mons.Object, pos: Pos32, idx: U32, game: Mons.Game): Mons.Game 2 | open game 3 | let obj = fn(Mons.Map.get(pos, idx, game.map)) 4 | let map = Mons.Map.set(pos, idx, obj, game.map) 5 | Mons.Game.set_map(map, game) -------------------------------------------------------------------------------- /src/Mons/Game/update_obj.fm: -------------------------------------------------------------------------------- 1 | Mons.Game.update_obj(obj: Mons.Object, pos: Pos32, idx: U32, game: Mons.Game): Mons.Game 2 | open game 3 | let map = Mons.Map.set(pos, idx, obj, game.map) 4 | Mons.Game.set_map(map, game) -------------------------------------------------------------------------------- /src/Mons/Kind/const.fm: -------------------------------------------------------------------------------- 1 | type Mons.Kind.const{ 2 | FOUNTAIN(model: U32, slice: U32), 3 | CHEST, 4 | CRYSTAL, 5 | PORTAL, 6 | } -------------------------------------------------------------------------------- /src/Mons/Kind/get_agi.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.get_agi(kind: Mons.Kind): U32 2 | case kind{ 3 | Mons: kind.agi 4 | Const: u3 5 | Terrain: u3 6 | Interactive: u3 7 | } -------------------------------------------------------------------------------- /src/Mons/Kind/get_skills.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.get_skills(kind: Mons.Kind): List(Mons.Skill) 2 | open Mons.Kind.attr(kind) as attr 3 | attr.skills -------------------------------------------------------------------------------- /src/Mons/Kind/inter.fm: -------------------------------------------------------------------------------- 1 | type Mons.Kind.inter{ 2 | Mons.Kind.inter.LEVER(id: U32), 3 | Mons.Kind.inter.MOVE, 4 | Mons.Kind.inter.HEAL, 5 | } -------------------------------------------------------------------------------- /src/Mons/Kind/mons.fm: -------------------------------------------------------------------------------- 1 | type Mons.Kind.mons{ 2 | HERO, 3 | MAGE, 4 | BEHOLDER, 5 | ZOIO, 6 | CYCLOPE, 7 | POISOLICK, 8 | TROWL, 9 | MIMIC, 10 | MIMIC2, 11 | AZULA, 12 | EMERELDER, 13 | EMERELDER2, 14 | } -------------------------------------------------------------------------------- /src/Mons/Kind/new_const.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.new_const(kin: Mons.Kind.const): Mons.Object 2 | Mons.Object.new_of_kind(Mons.Kind.Const(kin)) -------------------------------------------------------------------------------- /src/Mons/Kind/new_mon.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.new_mon(kin: Mons.Kind.mons, type: Mons.Type, agi: U32): Mons.Object 2 | Mons.Object.new_of_kind(Mons.Kind.Mons(kin, Bool.false, type, agi)) -------------------------------------------------------------------------------- /src/Mons/Kind/new_mons.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.new_mons(kin: Mons.Kind.mons, type: Mons.Type, agi: U32): List(Mons.Object) 2 | [ Mons.Object.new_of_kind(Mons.Kind.Mons(kin, Bool.false, type, agi)), 3 | // Mons.Kind.new_terrain(Mons.Kind.terrain.BUSH) 4 | ] -------------------------------------------------------------------------------- /src/Mons/Kind/new_terrain.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.new_terrain(kin: Mons.Kind.terrain): Mons.Object 2 | Mons.Object.new_of_kind(Mons.Kind.Terrain(kin)) -------------------------------------------------------------------------------- /src/Mons/Kind/set_default_battle_spr.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.set_default_battle_spr: Bool -> Image3D 2 | // (is_up) Mons.Assets.battle_croni_u 3 | (is_up) Image3D.empty -------------------------------------------------------------------------------- /src/Mons/Kind/set_pic.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.set_pic(spr: List(Image3D)): Image3D 2 | case spr{ 3 | nil: Image3D.empty, //Mons.Assets.void, 4 | cons: spr.head 5 | } -------------------------------------------------------------------------------- /src/Mons/Kind/set_static_sprites.fm: -------------------------------------------------------------------------------- 1 | Mons.Kind.set_static_sprites(spr: List(Image3D)): U32 -> U32 -> U32 -> Mons.Dir -> List(Image3D) 2 | (x,y,obj_ani,obj_dir) spr -------------------------------------------------------------------------------- /src/Mons/Map.fm: -------------------------------------------------------------------------------- 1 | Mons.Map: Type 2 | Map(List(Mons.Object)) -------------------------------------------------------------------------------- /src/Mons/Map/Dir.fm: -------------------------------------------------------------------------------- 1 | type Mons.Map.Dir { 2 | right, // r 3 | up, // u 4 | left, // l 5 | down, // d 6 | middle // m 7 | } -------------------------------------------------------------------------------- /src/Mons/Map/del.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.del(pos: Pos32, idx: U32, map: Mons.Map): Mons.Map 2 | let objs = Mons.Map.get_list(pos, map) 3 | let objs = List.delete_at.u32!(idx, objs) 4 | Mons.Map.set_list(pos, objs, map) -------------------------------------------------------------------------------- /src/Mons/Map/get.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.get(pos: Pos32, idx: U32, map: Mons.Map): Mons.Object 2 | let list = Mons.Map.get_list(pos, map) 3 | case List.at!(U32.to_nat(idx), list) as got { 4 | none: Mons.Object.void, 5 | some: got.value 6 | } -------------------------------------------------------------------------------- /src/Mons/Map/get_list.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.get_list(pos: Pos32, map: Mons.Map): List(Mons.Object) 2 | case Map.get!(U32.to_bits(pos), map) as got { 3 | none: [], 4 | some: got.value 5 | } -------------------------------------------------------------------------------- /src/Mons/Map/get_top.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.get_top(pos: Pos32, map: Mons.Map): Mons.Object 2 | Pair.snd!!(Mons.Map.pop(pos,map)) -------------------------------------------------------------------------------- /src/Mons/Map/new.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.new: Mons.Map 2 | Map.new! -------------------------------------------------------------------------------- /src/Mons/Map/push.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.push(pos: Pos32, obj: Mons.Object, map: Mons.Map): Mons.Map 2 | let objs = Mons.Map.get_list(pos, map) 3 | let objs = List.cons!(obj, objs) 4 | Mons.Map.set_list(pos, objs, map) -------------------------------------------------------------------------------- /src/Mons/Map/set.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.set(pos: Pos32, idx: U32, val: Mons.Object, map: Mons.Map): Mons.Map 2 | let list = Mons.Map.get_list(pos, map) 3 | let list = List.update_at!(U32.to_nat(idx), () val, list) 4 | Mons.Map.set_list(pos, list, map) -------------------------------------------------------------------------------- /src/Mons/Map/set_list.fm: -------------------------------------------------------------------------------- 1 | Mons.Map.set_list(pos: Pos32, objs: List(Mons.Object), map: Mons.Map): Mons.Map 2 | Map.set!(U32.to_bits(pos), objs, map) -------------------------------------------------------------------------------- /src/Mons/Object/get_ani.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.get_ani(obj: Mons.Object): U32 2 | open obj 3 | obj.ani -------------------------------------------------------------------------------- /src/Mons/Object/get_current_mon.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.get_current_mon(obj: Mons.Object): Mons.Object 2 | open obj 3 | let idx = U32.to_nat(obj.mon) 4 | case List.at!(idx, obj.bag) as mon { 5 | none: obj, 6 | some: mon.value 7 | } -------------------------------------------------------------------------------- /src/Mons/Object/get_dir.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.get_dir(obj: Mons.Object): Mons.Dir 2 | open obj 3 | obj.dir -------------------------------------------------------------------------------- /src/Mons/Object/get_dmg.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.get_dmg(obj: Mons.Object): U32 2 | open obj 3 | obj.dmg -------------------------------------------------------------------------------- /src/Mons/Object/get_kin.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.get_kin(obj: Mons.Object): Mons.Kind 2 | open obj 3 | obj.kin -------------------------------------------------------------------------------- /src/Mons/Object/get_pad.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.get_pad(obj: Mons.Object): Mons.Pad 2 | open obj 3 | obj.pad -------------------------------------------------------------------------------- /src/Mons/Object/heal.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.heal(obj: Mons.Object, val: U32): Mons.Object 2 | Mons.Object.set_dmg(obj, U32.sub(Mons.Object.get_dmg(obj), val)) -------------------------------------------------------------------------------- /src/Mons/Object/hero.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.hero: Mons.Object 2 | Mons.Object.new_of_kind(Mons.Kind.Mons(Mons.Kind.mons.HERO, Bool.false, Mons.Type.fire, u1)) -------------------------------------------------------------------------------- /src/Mons/Object/hit.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.hit(obj: Mons.Object, dmg: U32): Mons.Object 2 | Mons.Object.set_dmg(obj, U32.add(Mons.Object.get_dmg(obj), dmg)) -------------------------------------------------------------------------------- /src/Mons/Object/is_bag_full.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.is_bag_full(obj: Mons.Object): Bool 2 | open obj 3 | let size = List.length!(obj.bag) 4 | Nat.eql(size, 3) -------------------------------------------------------------------------------- /src/Mons/Object/is_free_to_move.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.is_free_to_move(obj: Mons.Object): Bool 2 | open obj 3 | U32.eql(obj.ani, u0) -------------------------------------------------------------------------------- /src/Mons/Object/is_full_bag.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.is_full_bag(obj: Mons.Object): Bool 2 | open obj 3 | let len = List.length!(obj.bag) 4 | Nat.eql(len, 3) -------------------------------------------------------------------------------- /src/Mons/Object/is_standing.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.is_standing(obj: Mons.Object): Bool 2 | U32.eql(Mons.Object.get_ani(obj),u0) -------------------------------------------------------------------------------- /src/Mons/Object/is_walking.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.is_walking(obj: Mons.Object): Bool 2 | open obj 3 | open obj.pad 4 | let is_walking_x = Bool.or(obj.pad.u, obj.pad.d) 5 | let is_walking_y = Bool.or(obj.pad.l, obj.pad.r) 6 | Bool.or(is_walking_x, is_walking_y) -------------------------------------------------------------------------------- /src/Mons/Object/new_of_kind.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.new_of_kind(kin: Mons.Kind): Mons.Object 2 | // kin, dir, pad, ani, dmg, bag, mon, bos, cap 3 | Mons.Object.new(kin, Mons.Dir.down, Mons.Pad.null, u0, u0, [], u0, [], {Nat.to_u32(11), []}, 4 | u0, Mons.Effect.clear) -------------------------------------------------------------------------------- /src/Mons/Object/pop_from_bag.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.pop_from_bag(obj: Mons.Object): Mons.Object 2 | open obj 3 | let qtd = List.length!(obj.bag) 4 | if Nat.eql(qtd, 1) then 5 | obj 6 | else 7 | let new_bag = List.drop!(1, obj.bag) 8 | Mons.Object.set_bag(new_bag, obj) -------------------------------------------------------------------------------- /src/Mons/Object/qtd_mons_defeated.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.qtd_mons_defeated(obj: Mons.Object): U32 2 | open obj 3 | Nat.to_u32(List.length!(Pair.snd!!(obj.cap))) -------------------------------------------------------------------------------- /src/Mons/Object/set_ani.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_ani(obj: Mons.Object, ani: U32): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, obj.pad, ani, obj.dmg, obj.bag, 4 | obj.mon, obj.bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_bag.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_bag(bag: List(Mons.Object), obj: Mons.Object): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, obj.pad, obj.ani, obj.dmg, bag, 4 | obj.mon, obj.bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_bos.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_bos(bos: List(Mons.Object), obj: Mons.Object): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, obj.pad, obj.ani, obj.dmg, obj.bag, 4 | obj.mon, bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_cap.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_cap(cap: Pair(U32, List(Mons.Object)), obj: Mons.Object): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, obj.pad, obj.ani, obj.dmg, obj.bag, 4 | obj.mon, obj.bos, cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_dir.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_dir(obj: Mons.Object, dir: Mons.Dir): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, dir, obj.pad, obj.ani, obj.dmg, obj.bag, 4 | obj.mon, obj.bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_dmg.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_dmg(obj: Mons.Object, dmg: U32): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, obj.pad, obj.ani, dmg, obj.bag, 4 | obj.mon, obj.bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_idl.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_idl(idl: U32, obj: Mons.Object): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, obj.pad, obj.ani, obj.dmg, obj.bag, 4 | obj.mon, obj.bos, obj.cap, idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_kin.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_kin(obj: Mons.Object, kin: Mons.Kind): Mons.Object 2 | open obj 3 | Mons.Object.new(kin, obj.dir, obj.pad, obj.ani, obj.dmg, obj.bag, 4 | obj.mon, obj.bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_mon.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_mon(idx: U32, obj: Mons.Object): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, obj.pad, obj.ani, obj.dmg, obj.bag, 4 | idx, obj.bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_pad.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_pad(obj: Mons.Object, pad: Mons.Pad): Mons.Object 2 | open obj 3 | Mons.Object.new(obj.kin, obj.dir, pad, obj.ani, obj.dmg, obj.bag, 4 | obj.mon, obj.bos, obj.cap, obj.idl, obj.eff) -------------------------------------------------------------------------------- /src/Mons/Object/set_pad_d.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_pad_d(obj: Mons.Object, val: Bool): Mons.Object 2 | open obj 3 | Mons.Object.set_pad(obj, Mons.Pad.set_d(obj.pad, val)) -------------------------------------------------------------------------------- /src/Mons/Object/set_pad_l.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_pad_l(obj: Mons.Object, val: Bool): Mons.Object 2 | open obj 3 | Mons.Object.set_pad(obj, Mons.Pad.set_l(obj.pad, val)) -------------------------------------------------------------------------------- /src/Mons/Object/set_pad_r.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_pad_r(obj: Mons.Object, val: Bool): Mons.Object 2 | open obj 3 | Mons.Object.set_pad(obj, Mons.Pad.set_r(obj.pad, val)) -------------------------------------------------------------------------------- /src/Mons/Object/set_pad_u.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.set_pad_u(obj: Mons.Object, val: Bool): Mons.Object 2 | open obj 3 | Mons.Object.set_pad(obj, Mons.Pad.set_u(obj.pad, val)) -------------------------------------------------------------------------------- /src/Mons/Object/update_interactive.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.update_interactive(obj: Mons.Object, fun: Mons.Kind -> Mons.Kind ): Mons.Object 2 | open obj 3 | Mons.Object.set_kin(obj, fun(obj.kin)) -------------------------------------------------------------------------------- /src/Mons/Object/void.fm: -------------------------------------------------------------------------------- 1 | Mons.Object.void: Mons.Object 2 | let void = Mons.Kind.Terrain(Mons.Kind.terrain.VOID) 3 | Mons.Object.new(void, Mons.Dir.down, Mons.Pad.null, u0, u0, [], u0, [], {u33, []}, 4 | u0, Mons.Effect.clear) -------------------------------------------------------------------------------- /src/Mons/Pad.fm: -------------------------------------------------------------------------------- 1 | type Mons.Pad { 2 | new(r: Bool, u: Bool, l: Bool, d: Bool) 3 | } -------------------------------------------------------------------------------- /src/Mons/Pad/null.fm: -------------------------------------------------------------------------------- 1 | Mons.Pad.null: Mons.Pad 2 | Mons.Pad.new(Bool.false, Bool.false, Bool.false, Bool.false) -------------------------------------------------------------------------------- /src/Mons/Pad/set_d.fm: -------------------------------------------------------------------------------- 1 | Mons.Pad.set_d(pad: Mons.Pad, val: Bool): Mons.Pad 2 | open pad 3 | Mons.Pad.new(pad.r, pad.u, pad.l, val) -------------------------------------------------------------------------------- /src/Mons/Pad/set_l.fm: -------------------------------------------------------------------------------- 1 | Mons.Pad.set_l(pad: Mons.Pad, val: Bool): Mons.Pad 2 | open pad 3 | Mons.Pad.new(pad.r, pad.u, val, pad.d) -------------------------------------------------------------------------------- /src/Mons/Pad/set_r.fm: -------------------------------------------------------------------------------- 1 | Mons.Pad.set_r(pad: Mons.Pad, val: Bool): Mons.Pad 2 | open pad 3 | Mons.Pad.new(val, pad.u, pad.l, pad.d) -------------------------------------------------------------------------------- /src/Mons/Pad/set_u.fm: -------------------------------------------------------------------------------- 1 | Mons.Pad.set_u(pad: Mons.Pad, val: Bool): Mons.Pad 2 | open pad 3 | Mons.Pad.new(pad.r, val, pad.l, pad.d) -------------------------------------------------------------------------------- /src/Mons/Sprite.fm: -------------------------------------------------------------------------------- 1 | type Mons.Sprite { 2 | new(x: U32, y: U32, z: U32, img: Image3D) 3 | } -------------------------------------------------------------------------------- /src/Mons/Turn/empty.fm: -------------------------------------------------------------------------------- 1 | Mons.Turn.empty: Mons.Turn 2 | Mons.Turn.new(Bool.false, Mons.Skill.none, Mons.Skill.none, u0) -------------------------------------------------------------------------------- /src/Mons/Turn/hero_run.fm: -------------------------------------------------------------------------------- 1 | Mons.Turn.hero_run(turn: Mons.Turn): Bool 2 | open turn 3 | U32.eql(turn.play, u5) -------------------------------------------------------------------------------- /src/Mons/Turn/hero_turn.fm: -------------------------------------------------------------------------------- 1 | Mons.Turn.hero_turn(turn: Mons.Turn): Bool 2 | open turn 3 | turn.exec_hero -------------------------------------------------------------------------------- /src/Mons/Turn/is_active.fm: -------------------------------------------------------------------------------- 1 | Mons.Turn.is_active(turn: Mons.Turn): Bool 2 | open turn 3 | U32.gtn(turn.play, u0) -------------------------------------------------------------------------------- /src/Mons/Turn/is_last_player_move.fm: -------------------------------------------------------------------------------- 1 | Mons.Turn.is_last_player_move(turn: Mons.Turn): Bool 2 | open turn 3 | U32.eql(turn.play, u1) -------------------------------------------------------------------------------- /src/Mons/Type.fm: -------------------------------------------------------------------------------- 1 | type Mons.Type { 2 | normal, 3 | earth, 4 | fire, 5 | water, 6 | grass, 7 | electric, 8 | psychic, 9 | ice, 10 | light, 11 | darkness 12 | } -------------------------------------------------------------------------------- /src/Mons/global_scr_mid.fm: -------------------------------------------------------------------------------- 1 | Mons.global_scr_mid: Pos32 2 | Pos32.new(u2048, u2048, u0) 3 | -------------------------------------------------------------------------------- /src/Mons/scr_h.fm: -------------------------------------------------------------------------------- 1 | Mons.scr_h: U32 2 | U32.mul(Pos32.get_y(Mons.scr_mid), u2) -------------------------------------------------------------------------------- /src/Mons/scr_mid.fm: -------------------------------------------------------------------------------- 1 | Mons.scr_mid: Pos32 2 | Pos32.new(u120, u80, u0) -------------------------------------------------------------------------------- /src/Mons/scr_w.fm: -------------------------------------------------------------------------------- 1 | Mons.scr_w: U32 2 | U32.mul(Pos32.get_x(Mons.scr_mid), u2) -------------------------------------------------------------------------------- /src/Mons/vox_mid.fm: -------------------------------------------------------------------------------- 1 | Mons.vox_mid: Pos32 2 | Pos32.new(u128, u128, u0) -------------------------------------------------------------------------------- /src/Nat.fm: -------------------------------------------------------------------------------- 1 | type Nat { 2 | zero, 3 | succ(pred: Nat), 4 | } -------------------------------------------------------------------------------- /src/Nat/add.fm: -------------------------------------------------------------------------------- 1 | Nat.add(n: Nat, m: Nat): Nat 2 | case n { 3 | zero: m, 4 | succ: Nat.succ(Nat.add(n.pred, m)), 5 | } 6 | -------------------------------------------------------------------------------- /src/Nat/add/succ_left.fm: -------------------------------------------------------------------------------- 1 | Nat.add.succ_left(a: Nat, b: Nat): (Nat.succ(a) + b) == Nat.succ(a + b) 2 | refl 3 | -------------------------------------------------------------------------------- /src/Nat/add/zero_left.fm: -------------------------------------------------------------------------------- 1 | Nat.add.zero_left(a: Nat): (0 + a) == a 2 | refl 3 | -------------------------------------------------------------------------------- /src/Nat/add/zero_right.fm: -------------------------------------------------------------------------------- 1 | Nat.add.zero_right(a: Nat): (a + 0) == a 2 | case a { 3 | zero: refl 4 | succ: 5 | let p0 = Nat.add.zero_right(a.pred) 6 | let p1 = Equal.apply!!(p0) 7 | p1 8 | }! 9 | -------------------------------------------------------------------------------- /src/Nat/apply.fm: -------------------------------------------------------------------------------- 1 | Nat.apply(n: Nat, f: (x:A) A, x: A): A 2 | case n { 3 | zero: x, 4 | succ: Nat.apply(n.pred, f, f(x)), 5 | } -------------------------------------------------------------------------------- /src/Nat/cmp.fm: -------------------------------------------------------------------------------- 1 | Nat.cmp(a: Nat, b: Nat): Cmp 2 | case a { 3 | zero: case b { 4 | zero: Cmp.eql, 5 | succ: Cmp.ltn, 6 | }, 7 | succ: case b { 8 | zero: Cmp.gtn, 9 | succ: Nat.cmp(a.pred, b.pred), 10 | }, 11 | } 12 | -------------------------------------------------------------------------------- /src/Nat/div.fm: -------------------------------------------------------------------------------- 1 | Nat.div(n: Nat, m: Nat): Nat 2 | Pair.fst!!(Nat.div_mod(n, m)) 3 | -------------------------------------------------------------------------------- /src/Nat/div_mod.fm: -------------------------------------------------------------------------------- 1 | Nat.div_mod(n: Nat, m: Nat): Pair(Nat, Nat) 2 | Nat.div_mod.go(n, m, Nat.zero) 3 | -------------------------------------------------------------------------------- /src/Nat/div_mod/go.fm: -------------------------------------------------------------------------------- 1 | Nat.div_mod.go(n: Nat, m: Nat, d: Nat): Pair(Nat, Nat) 2 | case Nat.sub_rem(n, m) as p { 3 | left: Nat.div_mod.go(p.value, m, Nat.succ(d)), 4 | right: Pair.new!!(d, n), 5 | } -------------------------------------------------------------------------------- /src/Nat/divides.fm: -------------------------------------------------------------------------------- 1 | Nat.divides(a: Nat, b: Nat): Type 2 | {x: Nat} (a*x) == b 3 | -------------------------------------------------------------------------------- /src/Nat/double.fm: -------------------------------------------------------------------------------- 1 | Nat.double(n: Nat): Nat 2 | case n { 3 | zero: Nat.zero, 4 | succ: Nat.succ(Nat.succ(Nat.double(n.pred))), 5 | } 6 | -------------------------------------------------------------------------------- /src/Nat/eql.fm: -------------------------------------------------------------------------------- 1 | Nat.eql(n: Nat, m: Nat): Bool 2 | case n { 3 | zero: case m { 4 | zero: Bool.true, 5 | succ: Bool.false, 6 | }, 7 | succ: case m { 8 | zero: Bool.false, 9 | succ: Nat.eql(n.pred, m.pred), 10 | }, 11 | } 12 | -------------------------------------------------------------------------------- /src/Nat/for.fm: -------------------------------------------------------------------------------- 1 | Nat.for(state: S, from: Nat, til: Nat, func: Nat -> S -> S): S 2 | if Nat.eql(from, til) then 3 | state 4 | else 5 | Nat.for(func(from, state), Nat.succ(from), til, func) 6 | -------------------------------------------------------------------------------- /src/Nat/from_base.fm: -------------------------------------------------------------------------------- 1 | Nat.from_base(base: Nat, ds: List(Nat)) : Nat 2 | Nat.from_base.go(base, List.reverse!(ds),1,0) 3 | -------------------------------------------------------------------------------- /src/Nat/from_base/go.fm: -------------------------------------------------------------------------------- 1 | Nat.from_base.go(b: Nat, ds: List(Nat), p: Nat, res: Nat) : Nat 2 | case ds { 3 | nil: res, 4 | cons: Nat.from_base.go(b,ds.tail,Nat.mul(b,p), Nat.add(Nat.mul(ds.head,p),res)) 5 | } -------------------------------------------------------------------------------- /src/Nat/gcd.fm: -------------------------------------------------------------------------------- 1 | Nat.gcd(n: Nat, m: Nat): Nat 2 | case n { 3 | zero: m, 4 | succ: Nat.gcd(Nat.mod(m, n), n) 5 | } 6 | -------------------------------------------------------------------------------- /src/Nat/gcd/succ.fm: -------------------------------------------------------------------------------- 1 | Nat.gcd.succ(a: Nat)(b: Nat): Nat.gcd(Nat.succ(a),b) == Nat.gcd(b % Nat.succ(a), Nat.succ(a)) 2 | refl 3 | -------------------------------------------------------------------------------- /src/Nat/gcd/zero_left.fm: -------------------------------------------------------------------------------- 1 | Nat.gcd.zero_left(a: Nat): Nat.gcd(0,a) == a 2 | refl 3 | -------------------------------------------------------------------------------- /src/Nat/gcd/zero_right.fm: -------------------------------------------------------------------------------- 1 | Nat.gcd.zero_right(a: Nat): Nat.gcd(a,0) == a 2 | case a { 3 | zero: refl 4 | succ: refl 5 | }! 6 | -------------------------------------------------------------------------------- /src/Nat/gte.fm: -------------------------------------------------------------------------------- 1 | Nat.gte(n: Nat, m: Nat): Bool 2 | case m { 3 | zero: Bool.true, 4 | succ: case n { 5 | zero: Bool.false, 6 | succ: Nat.gte(n.pred, m.pred), 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/Nat/gtn.fm: -------------------------------------------------------------------------------- 1 | Nat.gtn(n: Nat, m: Nat): Bool 2 | case n { 3 | zero: Bool.false, 4 | succ: case m { 5 | zero: Bool.true, 6 | succ: Nat.gtn(n.pred, m.pred), 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/half.fm: -------------------------------------------------------------------------------- 1 | Nat.half(n: Nat): Nat 2 | case n { 3 | zero: Nat.zero, 4 | succ: case n.pred { 5 | zero: Nat.zero, 6 | succ: Nat.succ(Nat.half(n.pred.pred)) 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/induction.fm: -------------------------------------------------------------------------------- 1 | Nat.induction(n: Nat): Type> -> (z: P(Nat.zero)) -> (s: ((m:Nat) -> P(m) -> P(Nat.succ(m)))) -> P(n) 2 |

(z) (s) n

(z, (pred) s(pred, Nat.induction(pred)

(z, s))) -------------------------------------------------------------------------------- /src/Nat/is_even.fm: -------------------------------------------------------------------------------- 1 | Nat.is_even(n: Nat): Bool 2 | case n { 3 | zero: true, 4 | succ: Bool.not(Nat.is_even(n.pred)), 5 | } -------------------------------------------------------------------------------- /src/Nat/is_zero.fm: -------------------------------------------------------------------------------- 1 | Nat.is_zero(n: Nat): Bool 2 | case n { 3 | zero: Bool.true, 4 | succ: Bool.false, 5 | } -------------------------------------------------------------------------------- /src/Nat/lcm.fm: -------------------------------------------------------------------------------- 1 | Nat.lcm(a: Nat, b: Nat): Nat 2 | (a * b) / Nat.gcd(a , b) 3 | -------------------------------------------------------------------------------- /src/Nat/lte.fm: -------------------------------------------------------------------------------- 1 | Nat.lte(n: Nat, m: Nat): Bool 2 | case n { 3 | zero: Bool.true, 4 | succ: case m { 5 | zero: Bool.false, 6 | succ: Nat.lte(n.pred, m.pred), 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/ltn.fm: -------------------------------------------------------------------------------- 1 | Nat.ltn(n: Nat, m: Nat): Bool 2 | case m { 3 | zero: Bool.false, 4 | succ: case n { 5 | zero: Bool.true, 6 | succ: Nat.ltn(n.pred, m.pred), 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/min.fm: -------------------------------------------------------------------------------- 1 | Nat.min(a: Nat, b: Nat): Nat 2 | case a { 3 | zero: 0, 4 | succ: case b { 5 | zero: 0, 6 | succ: Nat.succ(Nat.min(a.pred, b.pred)) 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/mod.fm: -------------------------------------------------------------------------------- 1 | Nat.mod(n: Nat, m: Nat): Nat 2 | Nat.mod.go(n, m, 0) -------------------------------------------------------------------------------- /src/Nat/mod/go.fm: -------------------------------------------------------------------------------- 1 | Nat.mod.go(n: Nat, m: Nat, r: Nat): Nat 2 | case m { 3 | zero: Nat.mod.go(n, r, m), 4 | succ: case n { 5 | zero: r, 6 | succ: Nat.mod.go(n.pred, m.pred, Nat.succ(r)), 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/mod/go_mod_one_equals_zero.fm: -------------------------------------------------------------------------------- 1 | Nat.mod.go_mod_one_equals_zero(a: Nat): Nat.mod.go(a, 1, 0) == 0 2 | case a{ 3 | zero: refl 4 | succ: Nat.mod.go_mod_one_equals_zero(a.pred) 5 | }! 6 | 7 | 8 | -------------------------------------------------------------------------------- /src/Nat/mod/go_self.fm: -------------------------------------------------------------------------------- 1 | Nat.mod.go_self(a: Nat) (b: Nat): Nat.mod.go(a, a, Nat.succ(b)) == 0 2 | case a{ 3 | zero: refl 4 | succ: Nat.mod.go_self(a.pred,Nat.succ(b)) 5 | }! 6 | 7 | 8 | -------------------------------------------------------------------------------- /src/Nat/mod/mod_one_equals_zero.fm: -------------------------------------------------------------------------------- 1 | Nat.mod.mod_one_equals_zero(a: Nat): (a % 1) == 0 2 | case a{ 3 | zero: refl 4 | succ: Nat.mod.go_mod_one_equals_zero(a.pred) 5 | }! 6 | -------------------------------------------------------------------------------- /src/Nat/mod/self.fm: -------------------------------------------------------------------------------- 1 | Nat.mod.self(a: Nat): (Nat.succ(a) % Nat.succ(a)) == 0 2 | Nat.mod.go_self(a,0) 3 | -------------------------------------------------------------------------------- /src/Nat/mod/zero_mod_equals_zero.fm: -------------------------------------------------------------------------------- 1 | Nat.mod.zero_mod_equals_zero(a: Nat): (0 % Nat.succ(a)) == 0 2 | refl 3 | -------------------------------------------------------------------------------- /src/Nat/mul.fm: -------------------------------------------------------------------------------- 1 | Nat.mul(n: Nat, m: Nat): Nat 2 | case m { 3 | zero: Nat.zero, 4 | succ: Nat.add(n, Nat.mul(n, m.pred)), 5 | } -------------------------------------------------------------------------------- /src/Nat/mul/comm.fm: -------------------------------------------------------------------------------- 1 | Nat.mul.comm(a: Nat, b: Nat): (a * b) == b * a 2 | case b { 3 | zero: mirror(Nat.mul.zero_left(a)) 4 | succ: mirror(Nat.mul.comm(Nat.succ(b.pred), a)) 5 | }! 6 | -------------------------------------------------------------------------------- /src/Nat/mul/one_left.fm: -------------------------------------------------------------------------------- 1 | Nat.mul.one_left(a: Nat): (1 * a) == a 2 | case a{ 3 | zero: refl 4 | succ: 5 | let h = Nat.mul.one_left(a.pred) 6 | Equal.apply!!(h) 7 | }! 8 | -------------------------------------------------------------------------------- /src/Nat/mul/one_right.fm: -------------------------------------------------------------------------------- 1 | Nat.mul.one_right(a: Nat): (a * 1) == a 2 | Nat.add.zero_right(a) 3 | -------------------------------------------------------------------------------- /src/Nat/mul/zero_left.fm: -------------------------------------------------------------------------------- 1 | Nat.mul.zero_left(a: Nat): (0 * a) == 0 2 | case a{ 3 | zero: refl 4 | succ: 5 | let h = Nat.mul.zero_left(a.pred) 6 | apply((x) (0+x), h) 7 | }! 8 | -------------------------------------------------------------------------------- /src/Nat/mul/zero_right.fm: -------------------------------------------------------------------------------- 1 | Nat.mul.zero_right(a: Nat): (a * 0) == 0 2 | refl 3 | -------------------------------------------------------------------------------- /src/Nat/odd.fm: -------------------------------------------------------------------------------- 1 | Nat.odd(n: Nat): Bool 2 | Nat.eql(Nat.mod(n, 2), 1) -------------------------------------------------------------------------------- /src/Nat/one_neq_zero.fm: -------------------------------------------------------------------------------- 1 | Nat.one_neq_zero: 1 != 0 2 | (e) 3 | let e = apply(Nat.is_zero, e) 4 | let e1 = mirror(e) 5 | Bool.true_neq_false(e1) 6 | -------------------------------------------------------------------------------- /src/Nat/pred.fm: -------------------------------------------------------------------------------- 1 | Nat.pred(n: Nat): Nat 2 | case n { 3 | zero: Nat.zero, 4 | succ: n.pred 5 | } -------------------------------------------------------------------------------- /src/Nat/same.fm: -------------------------------------------------------------------------------- 1 | Nat.same(n: Nat): Nat 2 | case n { 3 | zero: 0 4 | succ: Nat.succ(Nat.same(n.pred)) 5 | } -------------------------------------------------------------------------------- /src/Nat/show.fm: -------------------------------------------------------------------------------- 1 | Nat.show(n: Nat): String 2 | Nat.to_string_base(10,n) -------------------------------------------------------------------------------- /src/Nat/square.fm: -------------------------------------------------------------------------------- 1 | Nat.square(a: Nat): Nat 2 | Nat.mul(a, a) -------------------------------------------------------------------------------- /src/Nat/sub.fm: -------------------------------------------------------------------------------- 1 | Nat.sub(n: Nat, m: Nat): Nat 2 | case m { 3 | zero: n, 4 | succ: case n { 5 | zero: 0, 6 | succ: Nat.sub(n.pred, m.pred), 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/sub_rem.fm: -------------------------------------------------------------------------------- 1 | Nat.sub_rem(n: Nat, m: Nat): Either(Nat, Nat) 2 | case m { 3 | zero: Either.left!!(n), 4 | succ: case n { 5 | zero: Either.right!!(Nat.succ(m.pred)), 6 | succ: Nat.sub_rem(n.pred, m.pred), 7 | } 8 | } -------------------------------------------------------------------------------- /src/Nat/succ_inj.fm: -------------------------------------------------------------------------------- 1 | Nat.succ_inj(a: Nat, b: Nat, eq: Nat.succ(a) == Nat.succ(b)): a == b 2 | Equal.apply(eq) -------------------------------------------------------------------------------- /src/Nat/succ_neq_zero.fm: -------------------------------------------------------------------------------- 1 | Nat.succ_neq_zero(a: Nat): Nat.succ(a) != 0 2 | (e) 3 | let h = apply(Nat.is_zero, e) 4 | Bool.true_neq_false(mirror(h)) 5 | -------------------------------------------------------------------------------- /src/Nat/sum.fm: -------------------------------------------------------------------------------- 1 | Nat.sum(n: Nat): Nat 2 | Nat.sum.go(n, Nat.zero) -------------------------------------------------------------------------------- /src/Nat/sum/go.fm: -------------------------------------------------------------------------------- 1 | Nat.sum.go(n: Nat , r: Nat): Nat //loop// 2 | case n { 3 | zero: r, 4 | succ: Nat.sum.go(n.pred, Nat.add(n, r)) 5 | } -------------------------------------------------------------------------------- /src/Nat/to_base.fm: -------------------------------------------------------------------------------- 1 | Nat.to_base(base: Nat, nat: Nat): List(Nat) 2 | Nat.to_base.go(base, nat, List.nil) -------------------------------------------------------------------------------- /src/Nat/to_bits.fm: -------------------------------------------------------------------------------- 1 | Nat.to_bits(n: Nat): Bits 2 | case n { 3 | zero: Bits.e, 4 | succ: Bits.inc(Nat.to_bits(n.pred)) 5 | } -------------------------------------------------------------------------------- /src/Nat/to_f64.fm: -------------------------------------------------------------------------------- 1 | Nat.to_f64(s: Bool, a: Nat, b: Nat): F64 2 | Nat.to_f64(s, a, b) -------------------------------------------------------------------------------- /src/Nat/to_string.fm: -------------------------------------------------------------------------------- 1 | Nat.to_string(n: Nat): String 2 | case n { 3 | zero: String.cons(Char.parse("z"), String.nil), 4 | succ: String.cons(Char.parse("s"), Nat.to_string(n.pred)) 5 | } -------------------------------------------------------------------------------- /src/Nat/to_string_base.fm: -------------------------------------------------------------------------------- 1 | Nat.to_string_base(base: Nat, nat: Nat): String 2 | List.fold!(Nat.to_base(base, nat))!( 3 | String.nil, 4 | (n, str) String.cons(Nat.show_digit(base,n), str)) -------------------------------------------------------------------------------- /src/Nat/to_string_unary.fm: -------------------------------------------------------------------------------- 1 | Nat.to_string_unary(n: Nat): String 2 | case n { 3 | zero: String.nil, 4 | succ: String.cons('1', Nat.to_string_unary(n.pred)) 5 | } -------------------------------------------------------------------------------- /src/Nat/to_u16.fm: -------------------------------------------------------------------------------- 1 | Nat.to_u16(n: Nat): U16 2 | Nat.apply(n, U16.inc, U16.zero) 3 | -------------------------------------------------------------------------------- /src/Nat/to_u32.fm: -------------------------------------------------------------------------------- 1 | Nat.to_u32(n: Nat): U32 2 | Nat.apply(n, U32.inc, U32.zero) 3 | -------------------------------------------------------------------------------- /src/Nat/to_u64.fm: -------------------------------------------------------------------------------- 1 | Nat.to_u64(n: Nat): U64 2 | Nat.apply(n, U64.inc, U64.zero) -------------------------------------------------------------------------------- /src/Nat/to_u8.fm: -------------------------------------------------------------------------------- 1 | Nat.to_u8(n: Nat): U8 2 | Nat.apply(n, U8.inc, U8.zero) -------------------------------------------------------------------------------- /src/Not.fm: -------------------------------------------------------------------------------- 1 | Not(P: Type): Type 2 | P -> Empty 3 | -------------------------------------------------------------------------------- /src/Pair.fm: -------------------------------------------------------------------------------- 1 | type Pair { 2 | new(fst: A, snd: B) 3 | } 4 | -------------------------------------------------------------------------------- /src/Pair/fst.fm: -------------------------------------------------------------------------------- 1 | Pair.fst(pair: Pair(A, B)): A 2 | case pair { 3 | new: pair.fst 4 | } -------------------------------------------------------------------------------- /src/Pair/functor.fm: -------------------------------------------------------------------------------- 1 | Pair.functor: Functor(Pair(A)) 2 | Functor.new(Pair.map) -------------------------------------------------------------------------------- /src/Pair/map.fm: -------------------------------------------------------------------------------- 1 | Pair.map(f: B -> C, p: Pair(A, B)): Pair(A, C) 2 | case p { 3 | new: Pair.new(p.fst, f(p.snd)) 4 | } -------------------------------------------------------------------------------- /src/Pair/snd.fm: -------------------------------------------------------------------------------- 1 | Pair.snd(pair: Pair(A, B)): B 2 | case pair { 3 | new: pair.snd 4 | } -------------------------------------------------------------------------------- /src/Parser.fm: -------------------------------------------------------------------------------- 1 | Parser(V: Type): Type 2 | Nat -> String -> Parser.Reply(V) -------------------------------------------------------------------------------- /src/Parser/ErrorAt.fm: -------------------------------------------------------------------------------- 1 | type Parser.ErrorAt { 2 | new(idx: Nat, code: String, err: String) 3 | } -------------------------------------------------------------------------------- /src/Parser/Reply.fm: -------------------------------------------------------------------------------- 1 | type Parser.Reply { 2 | error(idx: Nat, code: String, err: String), 3 | value(idx: Nat, code: String, val: V), 4 | } 5 | -------------------------------------------------------------------------------- /src/Parser/bind.fm: -------------------------------------------------------------------------------- 1 | Parser.bind(parse: Parser(A), next: A -> Parser(B)): Parser(B) 2 | (idx,code) case parse(idx,code) as reply { 3 | error: Parser.Reply.error(reply.idx, reply.code, reply.err), 4 | value: next(reply.val, reply.idx, reply.code), 5 | } -------------------------------------------------------------------------------- /src/Parser/consume.fm: -------------------------------------------------------------------------------- 1 | // TODO: remove Parser.spaces_text 2 | Parser.consume(text: String): Parser(Unit) 3 | do Parser { 4 | Parser.spaces; 5 | Parser.text(text); 6 | } 7 | -------------------------------------------------------------------------------- /src/Parser/eof.fm: -------------------------------------------------------------------------------- 1 | Parser.eof: Parser(Unit) 2 | (idx,code) case code { 3 | nil: Parser.Reply.value!(idx, code, Unit.new), 4 | cons: Parser.Reply.error!(idx, code, "Expected end-of-file."), 5 | } -------------------------------------------------------------------------------- /src/Parser/fail.fm: -------------------------------------------------------------------------------- 1 | Parser.fail(error: String): Parser(V) 2 | (idx,code) Parser.Reply.error(idx, code, error) -------------------------------------------------------------------------------- /src/Parser/first_of.fm: -------------------------------------------------------------------------------- 1 | Parser.first_of(pars: List(Parser(A))): Parser(A) 2 | Parser.first_of.go(pars, Maybe.none!) -------------------------------------------------------------------------------- /src/Parser/get_code.fm: -------------------------------------------------------------------------------- 1 | Parser.get_code: Parser(String) 2 | (idx, code) Parser.Reply.value!(idx, code, code) -------------------------------------------------------------------------------- /src/Parser/get_index.fm: -------------------------------------------------------------------------------- 1 | Parser.get_index: Parser(Nat) 2 | (idx, code) Parser.Reply.value!(idx, code, idx) -------------------------------------------------------------------------------- /src/Parser/if_not.fm: -------------------------------------------------------------------------------- 1 | Parser.if_not(a: Parser(Unit), b: Parser(A)): Parser(A) 2 | (idx,code) case a(idx,code) { 3 | error: b(idx,code), 4 | value: Parser.Reply.error(idx, code, "Prevented."), 5 | } -------------------------------------------------------------------------------- /src/Parser/is_eof.fm: -------------------------------------------------------------------------------- 1 | Parser.is_eof: Parser(Bool) 2 | (idx,code) case code { 3 | nil: Parser.Reply.value!(idx, code, Bool.true), 4 | cons: Parser.Reply.value!(idx, code, Bool.false), 5 | } -------------------------------------------------------------------------------- /src/Parser/log.fm: -------------------------------------------------------------------------------- 1 | Parser.log(str: String): Parser(Unit) 2 | (idx, code) Debug.log!(str, (x) Parser.Reply.value!(idx, code, Unit.new)) -------------------------------------------------------------------------------- /src/Parser/log_code.fm: -------------------------------------------------------------------------------- 1 | Parser.log_code: Parser(Unit) 2 | (idx, code) Debug.log!(code, (x) Parser.Reply.value!(idx, code, Unit.new)) -------------------------------------------------------------------------------- /src/Parser/many.fm: -------------------------------------------------------------------------------- 1 | Parser.many(parser: Parser(V)): Parser(List(V)) 2 | Parser.many.go(parser, (x) x) -------------------------------------------------------------------------------- /src/Parser/many1.fm: -------------------------------------------------------------------------------- 1 | Parser.many1(parser: Parser(V)): Parser(List(V)) 2 | do Parser { 3 | var head = parser; 4 | var tail = Parser.many(parser); 5 | return List.cons(head, tail); 6 | } -------------------------------------------------------------------------------- /src/Parser/monad.fm: -------------------------------------------------------------------------------- 1 | Parser.monad: Monad(Parser) 2 | Monad.new(Parser.bind, Parser.pure) -------------------------------------------------------------------------------- /src/Parser/nat.fm: -------------------------------------------------------------------------------- 1 | Parser.nat: Parser(Nat) 2 | do Parser { 3 | var digits = Parser.many1(Parser.digit); 4 | return Nat.from_base(10, digits); 5 | } 6 | -------------------------------------------------------------------------------- /src/Parser/one.fm: -------------------------------------------------------------------------------- 1 | Parser.one: Parser(Char) 2 | (idx,code) case code { 3 | nil: Parser.Reply.error(idx, code, "Unexpected end of file."), 4 | cons: Parser.Reply.value(Nat.succ(idx), code.tail, code.head), 5 | } 6 | -------------------------------------------------------------------------------- /src/Parser/pure.fm: -------------------------------------------------------------------------------- 1 | Parser.pure(value: V): Parser(V) 2 | (idx,code) Parser.Reply.value(idx, code, value) 3 | -------------------------------------------------------------------------------- /src/Parser/run.fm: -------------------------------------------------------------------------------- 1 | Parser.run(parser: Parser(A), code: String): Maybe(A) 2 | case parser(0, code) as parsed { 3 | error: none 4 | value: some(parsed.val) 5 | } 6 | -------------------------------------------------------------------------------- /src/Parser/set_index.fm: -------------------------------------------------------------------------------- 1 | Parser.set_index(new_idx: Nat): Parser(Unit) 2 | (idx, code) Parser.Reply.value!(new_idx, code, Unit.new) 3 | -------------------------------------------------------------------------------- /src/Parser/spaces.fm: -------------------------------------------------------------------------------- 1 | Parser.spaces: Parser(List(Unit)) 2 | Parser.many!(Parser.first_of!([ 3 | Parser.text(" "), 4 | Parser.text("\n"), 5 | ])) -------------------------------------------------------------------------------- /src/Parser/spaces_text.fm: -------------------------------------------------------------------------------- 1 | Parser.spaces_text(text: String): Parser(Unit) 2 | do Parser { 3 | Parser.spaces; 4 | Parser.text(text); 5 | } -------------------------------------------------------------------------------- /src/Parser/text.fm: -------------------------------------------------------------------------------- 1 | Parser.text(text: String): Parser(Unit) 2 | (idx,code) case Parser.text.go(text, idx,code) as reply { 3 | error: Parser.Reply.error(idx, code, reply.err), 4 | value: Parser.Reply.value(reply.idx, reply.code, reply.val), 5 | } -------------------------------------------------------------------------------- /src/Parser/until.fm: -------------------------------------------------------------------------------- 1 | Parser.until(until: Parser(Unit), parse: Parser(V)): Parser(List(V)) 2 | Parser.until.go(until, parse, []) 3 | -------------------------------------------------------------------------------- /src/Parser/until1.fm: -------------------------------------------------------------------------------- 1 | Parser.until1(cond: Parser(Unit), parser: Parser(V)): Parser(List(V)) 2 | do Parser { 3 | var head = parser; 4 | var tail = Parser.until(cond, parser); 5 | return List.cons(head, tail); 6 | } -------------------------------------------------------------------------------- /src/Pos32.fm: -------------------------------------------------------------------------------- 1 | Pos32: Type 2 | U32 -------------------------------------------------------------------------------- /src/Pos32/new.fm: -------------------------------------------------------------------------------- 1 | Pos32.new(x: U32, y: U32, z: U32): Pos32 2 | let pos = 0u 3 | let pos = U32.or(pos, x) 4 | let pos = U32.or(pos, U32.shl(y, 12u)) 5 | let pos = U32.or(pos, U32.shl(z, 24u)) 6 | pos 7 | -------------------------------------------------------------------------------- /src/Provit/0.fm: -------------------------------------------------------------------------------- 1 | Provit.0(x: Bool): x == x 2 | refl -------------------------------------------------------------------------------- /src/Queue.fm: -------------------------------------------------------------------------------- 1 | type Queue { 2 | new(front: List(A), size_front: Nat, rear: List(A), size_rear: Nat) 3 | } -------------------------------------------------------------------------------- /src/Queue/cons.fm: -------------------------------------------------------------------------------- 1 | Queue.cons(a: A, q: Queue(A)): Queue(A) 2 | open q 3 | let new_f = List.cons(a, q.front) 4 | let new_sf = Nat.add(q.size_front, 1) 5 | Queue.balance(new_f, new_sf, q.rear, q.size_rear) -------------------------------------------------------------------------------- /src/Queue/empty.fm: -------------------------------------------------------------------------------- 1 | Queue.empty: Queue(A) 2 | Queue.new(List.nil, 0, List.nil, 0) -------------------------------------------------------------------------------- /src/Queue/foldr.fm: -------------------------------------------------------------------------------- 1 | Queue.foldr(b: B, f: A -> B -> B, q: Queue(A)): B 2 | open q 3 | let as_list = List.concat(q.front, List.reverse(q.rear)) 4 | List.foldr(b, f, as_list) -------------------------------------------------------------------------------- /src/Queue/from_list.fm: -------------------------------------------------------------------------------- 1 | Queue.from_list(as: List(A)): Queue(A) 2 | let len = List.length(as) 3 | Queue.balance(as, len, List.nil, 0) -------------------------------------------------------------------------------- /src/Queue/head.fm: -------------------------------------------------------------------------------- 1 | Queue.head(q: Queue(A)): Maybe(A) 2 | open q 3 | case q.front { 4 | nil : Maybe.none, 5 | cons: Maybe.some(q.front.head) 6 | } -------------------------------------------------------------------------------- /src/Queue/length.fm: -------------------------------------------------------------------------------- 1 | Queue.length(q: Queue(A)): Nat 2 | open q 3 | Nat.add(q.size_front, q.size_rear) -------------------------------------------------------------------------------- /src/Queue/map.fm: -------------------------------------------------------------------------------- 1 | Queue.map(f: A -> B, q: Queue(A)): Queue(B) 2 | open q 3 | let new_f = List.map!!(f, q.front) 4 | let new_r = List.map!!(f, q.rear) 5 | Queue.new!(new_f, q.size_front, new_r, q.size_rear) -------------------------------------------------------------------------------- /src/Queue/max_diff.fm: -------------------------------------------------------------------------------- 1 | Queue.max_diff : Nat 2 | 2 -------------------------------------------------------------------------------- /src/Queue/null.fm: -------------------------------------------------------------------------------- 1 | Queue.null(q: Queue(A)): Bool 2 | open q 3 | let front_is_empty = Nat.eql(q.size_front, 0) 4 | let rear_is_empty = Nat.eql(q.size_rear, 0) 5 | Bool.and(front_is_empty, rear_is_empty) -------------------------------------------------------------------------------- /src/Queue/snoc.fm: -------------------------------------------------------------------------------- 1 | Queue.snoc(a: A, q: Queue(A)): Queue(A) 2 | open q 3 | let new_rear = List.cons(a, q.rear) 4 | Queue.balance(q.front, q.size_front, new_rear, Nat.add(q.size_rear, 1)) -------------------------------------------------------------------------------- /src/Queue/to_list.fm: -------------------------------------------------------------------------------- 1 | Queue.to_list(q: Queue(A)): List(A) 2 | open q 3 | List.concat(q.front, List.reverse(q.rear)) -------------------------------------------------------------------------------- /src/Set.fm: -------------------------------------------------------------------------------- 1 | Set: Type 2 | Map(Unit) 3 | -------------------------------------------------------------------------------- /src/Set/del.fm: -------------------------------------------------------------------------------- 1 | Set.del(key: Bits, set: Set): Set 2 | Map.delete(key, set) -------------------------------------------------------------------------------- /src/Set/has.fm: -------------------------------------------------------------------------------- 1 | Set.has(bits: Bits, set: Set): Bool 2 | case Map.get(bits, set) { 3 | none: Bool.false, 4 | some: Bool.true, 5 | } -------------------------------------------------------------------------------- /src/Set/mut/del.fm: -------------------------------------------------------------------------------- 1 | Set.mut.del(key: Bits, set: Set): Set 2 | Set.del(key, set) 3 | -------------------------------------------------------------------------------- /src/Set/mut/has.fm: -------------------------------------------------------------------------------- 1 | Set.mut.has(bits: Bits, set: Set): Bool 2 | Set.has(bits, set) 3 | -------------------------------------------------------------------------------- /src/Set/mut/new.fm: -------------------------------------------------------------------------------- 1 | Set.mut.new(a: Unit): Set 2 | Set.new 3 | -------------------------------------------------------------------------------- /src/Set/mut/set.fm: -------------------------------------------------------------------------------- 1 | Set.mut.set(bits: Bits, set: Set): Set 2 | Set.set(bits, set) 3 | -------------------------------------------------------------------------------- /src/Set/new.fm: -------------------------------------------------------------------------------- 1 | Set.new: Set 2 | Map.new 3 | -------------------------------------------------------------------------------- /src/Set/set.fm: -------------------------------------------------------------------------------- 1 | Set.set(bits: Bits, set: Set): Set 2 | Map.set(bits, Unit.new, set) -------------------------------------------------------------------------------- /src/Sigma.fm: -------------------------------------------------------------------------------- 1 | type Sigma (A: Type) (B: A -> Type) { 2 | new(fst: A, snd: B(fst)) 3 | } 4 | -------------------------------------------------------------------------------- /src/Sigma/fst.fm: -------------------------------------------------------------------------------- 1 | Sigma.fst Type>(sig: Sigma(A, B)): A 2 | case sig { 3 | new: sig.fst 4 | } 5 | -------------------------------------------------------------------------------- /src/Sigma/snd.fm: -------------------------------------------------------------------------------- 1 | Sigma.snd Type>(sig: Sigma(A, B)): B(Sigma.fst(sig)) 2 | case sig { 3 | new: sig.snd 4 | }: B(Sigma.fst(sig)) -------------------------------------------------------------------------------- /src/String.fm: -------------------------------------------------------------------------------- 1 | type String { 2 | nil, 3 | cons(head: Char, tail: String), 4 | } 5 | -------------------------------------------------------------------------------- /src/String/Builder.fm: -------------------------------------------------------------------------------- 1 | String.Builder: Type 2 | String -> String -------------------------------------------------------------------------------- /src/String/Builder/concat.fm: -------------------------------------------------------------------------------- 1 | String.Builder.concat(a: String.Builder, b: String.Builder): String.Builder 2 | (x) a(b(x)) -------------------------------------------------------------------------------- /src/String/Builder/new.fm: -------------------------------------------------------------------------------- 1 | String.Builder.new : String.Builder 2 | (x) x -------------------------------------------------------------------------------- /src/String/Builder/snoc.fm: -------------------------------------------------------------------------------- 1 | String.Builder.snoc(c: Char, lb: String.Builder) : String.Builder 2 | (x) lb(String.cons(c,x)) -------------------------------------------------------------------------------- /src/String/append.fm: -------------------------------------------------------------------------------- 1 | String.append(as: String, a: Char): String 2 | case as{ 3 | nil : String.pure(a) 4 | cons: String.cons(as.head,String.append(as.tail, a)) 5 | } -------------------------------------------------------------------------------- /src/String/concat.fm: -------------------------------------------------------------------------------- 1 | String.concat(as: String, bs: String): String 2 | case as { 3 | nil: bs, 4 | cons: String.cons(as.head, String.concat(as.tail,bs)), 5 | } -------------------------------------------------------------------------------- /src/String/drop.fm: -------------------------------------------------------------------------------- 1 | String.drop(n: Nat, xs: String): String 2 | case n{ 3 | zero: xs 4 | succ: case xs{ 5 | nil : String.nil 6 | cons: String.drop(n.pred,xs.tail) 7 | } 8 | } -------------------------------------------------------------------------------- /src/String/ends_with.fm: -------------------------------------------------------------------------------- 1 | String.ends_with(xs: String, match: String): Bool 2 | let xs_reserved = String.reverse(xs) 3 | let match_reversed = String.reverse(match) 4 | String.starts_with(xs_reserved, match_reversed) -------------------------------------------------------------------------------- /src/String/filter.fm: -------------------------------------------------------------------------------- 1 | String.filter(f: Char -> Bool, xs: String): String 2 | case xs{ 3 | nil : String.nil 4 | cons: case f(xs.head){ 5 | true : String.cons(xs.head,String.filter(f, xs.tail)) 6 | false: String.filter(f, xs.tail) 7 | } 8 | } -------------------------------------------------------------------------------- /src/String/flatten.fm: -------------------------------------------------------------------------------- 1 | String.flatten(xs: List(String)): String 2 | String.flatten.go(xs, "") -------------------------------------------------------------------------------- /src/String/flatten/go.fm: -------------------------------------------------------------------------------- 1 | String.flatten.go(xs: List(String), res: String): String 2 | case xs { 3 | nil: res, 4 | cons: String.flatten.go(xs.tail, String.concat(res, xs.head)), 5 | } -------------------------------------------------------------------------------- /src/String/fold.fm: -------------------------------------------------------------------------------- 1 | String.fold(xs: String) : -> P -> (Char -> P -> P) -> P 2 |

(nil, cons) 3 | case xs{ 4 | nil : nil 5 | cons: cons(xs.head, String.fold(xs.tail)

(nil, cons)) 6 | } -------------------------------------------------------------------------------- /src/String/from_list.fm: -------------------------------------------------------------------------------- 1 | String.from_list(xs: List(Char)) : String 2 | case xs{ 3 | nil : String.nil 4 | cons: String.cons(xs.head,String.from_list(xs.tail)) 5 | } -------------------------------------------------------------------------------- /src/String/head.fm: -------------------------------------------------------------------------------- 1 | String.head(xs: String): Maybe(Char) 2 | case xs{ 3 | nil : Maybe.none! 4 | cons: Maybe.some!(xs.head) 5 | } -------------------------------------------------------------------------------- /src/String/imap.fm: -------------------------------------------------------------------------------- 1 | String.imap(f: Nat -> Char -> Char, xs: String): String 2 | case xs{ 3 | nil : String.nil 4 | cons: String.cons(f(0,xs.head),String.imap((n) f(Nat.succ(n)),xs.tail)) 5 | } -------------------------------------------------------------------------------- /src/String/includes.fm: -------------------------------------------------------------------------------- 1 | String.includes(xs: String, match: String): Bool 2 | case String.starts_with(xs, match){ 3 | true : Bool.true 4 | false: case String.includes.go(xs, match){ 5 | nil : Bool.false 6 | cons: Bool.true 7 | } 8 | } -------------------------------------------------------------------------------- /src/String/includes/go.fm: -------------------------------------------------------------------------------- 1 | String.includes.go(xs: String, match: String): String 2 | case xs{ 3 | nil : String.nil 4 | cons: case String.starts_with(xs.tail, match){ 5 | true : xs.tail 6 | false: String.includes.go(xs.tail, match) 7 | } 8 | } -------------------------------------------------------------------------------- /src/String/intercalate.fm: -------------------------------------------------------------------------------- 1 | String.intercalate(sep: String, xs: List(String)): String 2 | String.flatten(List.intersperse!(sep,xs)) -------------------------------------------------------------------------------- /src/String/intersperse.fm: -------------------------------------------------------------------------------- 1 | String.intersperse(sep: Char, xs: String): String 2 | case xs{ 3 | nil : String.nil 4 | cons: case xs.tail{ 5 | nil : String.pure(xs.head) 6 | cons: String.cons(xs.head,String.cons(sep,String.intersperse(sep,xs.tail))) 7 | } 8 | } -------------------------------------------------------------------------------- /src/String/is_empty.fm: -------------------------------------------------------------------------------- 1 | String.is_empty(str: String): Bool 2 | case str { 3 | nil: Bool.true, 4 | cons: Bool.false, 5 | } -------------------------------------------------------------------------------- /src/String/join.fm: -------------------------------------------------------------------------------- 1 | String.join(sep: String, list: List(String)): String 2 | String.join.go(sep, list, Bool.true) -------------------------------------------------------------------------------- /src/String/length.fm: -------------------------------------------------------------------------------- 1 | String.length(xs: String): Nat 2 | String.length.go(xs, 0) -------------------------------------------------------------------------------- /src/String/length/go.fm: -------------------------------------------------------------------------------- 1 | String.length.go(xs: String, n: Nat): Nat 2 | case xs { 3 | nil : n, 4 | cons: String.length.go(xs.tail, Nat.succ(n)) 5 | } -------------------------------------------------------------------------------- /src/String/length32.fm: -------------------------------------------------------------------------------- 1 | String.length32(xs: String): U32 2 | String.length32.go(xs, U32.zero) -------------------------------------------------------------------------------- /src/String/length32/go.fm: -------------------------------------------------------------------------------- 1 | String.length32.go(xs: String, n: U32): U32 2 | case xs{ 3 | nil : n 4 | cons: String.length32.go(xs.tail, U32.inc(n)) 5 | } -------------------------------------------------------------------------------- /src/String/map.fm: -------------------------------------------------------------------------------- 1 | String.map(f: Char -> Char, as: String): String 2 | case as{ 3 | nil : String.nil 4 | cons: String.cons(f(as.head),String.map(f,as.tail)) 5 | } -------------------------------------------------------------------------------- /src/String/not_empty.fm: -------------------------------------------------------------------------------- 1 | String.not_empty(xs: String): Type 2 | case xs{ 3 | nil : Empty 4 | cons: Unit 5 | } -------------------------------------------------------------------------------- /src/String/null.fm: -------------------------------------------------------------------------------- 1 | String.null(xs: String): Bool 2 | case xs{ 3 | nil : Bool.true 4 | cons: Bool.false 5 | } -------------------------------------------------------------------------------- /src/String/pad_left.fm: -------------------------------------------------------------------------------- 1 | String.pad_left(size: Nat, chr: Char, str: String): String 2 | String.reverse(String.pad_right(size, chr, String.reverse(str))) -------------------------------------------------------------------------------- /src/String/pure.fm: -------------------------------------------------------------------------------- 1 | String.pure(x : Char) : String 2 | String.cons(x, String.nil) -------------------------------------------------------------------------------- /src/String/remove_start_with.fm: -------------------------------------------------------------------------------- 1 | String.remove_start_with(xs: String, match: String): String 2 | case xs{ 3 | nil : String.nil 4 | cons: case String.starts_with(xs, match){ 5 | true : String.remove_start_with.go(xs, match) 6 | false: xs 7 | } 8 | } -------------------------------------------------------------------------------- /src/String/repeat.fm: -------------------------------------------------------------------------------- 1 | String.repeat(xs: String, n: Nat): String 2 | case n{ 3 | zero: String.nil 4 | succ: String.concat(xs, String.repeat(xs, n.pred)) 5 | } -------------------------------------------------------------------------------- /src/String/reverse.fm: -------------------------------------------------------------------------------- 1 | String.reverse(xs: String) : String 2 | String.reverse.go(xs,String.nil) -------------------------------------------------------------------------------- /src/String/reverse/go.fm: -------------------------------------------------------------------------------- 1 | String.reverse.go(xs: String, res: String): String 2 | case xs { 3 | nil: res, 4 | cons: String.reverse.go(xs.tail,String.cons(xs.head,res)), 5 | } -------------------------------------------------------------------------------- /src/String/run_builder.fm: -------------------------------------------------------------------------------- 1 | String.run_builder(lb: String.Builder): String 2 | lb(String.nil) -------------------------------------------------------------------------------- /src/String/show.fm: -------------------------------------------------------------------------------- 1 | String.show(xs: String): String 2 | String.flatten(["\"",xs,"\""]) -------------------------------------------------------------------------------- /src/String/slice.fm: -------------------------------------------------------------------------------- 1 | String.slice(i: Nat, j: Nat, xs: String): String 2 | String.take(Nat.sub(j, i), String.drop(i, xs)) -------------------------------------------------------------------------------- /src/String/split.fm: -------------------------------------------------------------------------------- 1 | String.split(xs: String, match: String): List(String) 2 | String.split.go(xs, match, "") -------------------------------------------------------------------------------- /src/String/take.fm: -------------------------------------------------------------------------------- 1 | String.take(n: Nat, xs: String): String 2 | case xs{ 3 | nil : String.nil 4 | cons: case n{ 5 | zero : String.nil 6 | succ: String.cons(xs.head,String.take(n.pred, xs.tail)) 7 | } 8 | } -------------------------------------------------------------------------------- /src/String/to_bits.fm: -------------------------------------------------------------------------------- 1 | String.to_bits(str: String): Bits 2 | case str{ 3 | nil : Bits.e 4 | cons: Bits.concat(U16.to_bits(str.head), String.to_bits(str.tail)) 5 | } -------------------------------------------------------------------------------- /src/String/to_builder.fm: -------------------------------------------------------------------------------- 1 | String.to_builder(string: String) : String.Builder 2 | String.to_builder.go(string, String.Builder.new) -------------------------------------------------------------------------------- /src/String/to_builder/go.fm: -------------------------------------------------------------------------------- 1 | String.to_builder.go(string: String, lb: String.Builder) : String.Builder 2 | case string{ 3 | nil : lb 4 | cons: String.to_builder.go(string.tail, String.Builder.snoc(string.head, lb)) 5 | } -------------------------------------------------------------------------------- /src/String/to_list.fm: -------------------------------------------------------------------------------- 1 | String.to_list(str: String): List(Char) 2 | case str{ 3 | nil : List.nil! 4 | cons: List.cons!(str.head, String.to_list(str.tail)) 5 | } -------------------------------------------------------------------------------- /src/The.fm: -------------------------------------------------------------------------------- 1 | type The ~ (x: A) { 2 | value(x: A) ~ (x: x) 3 | } 4 | -------------------------------------------------------------------------------- /src/U16.fm: -------------------------------------------------------------------------------- 1 | type U16 { 2 | new(value: Word(16)) 3 | } 4 | -------------------------------------------------------------------------------- /src/U16/add.fm: -------------------------------------------------------------------------------- 1 | U16.add(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.add!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/and.fm: -------------------------------------------------------------------------------- 1 | U16.and(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.and!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/btw.fm: -------------------------------------------------------------------------------- 1 | U16.btw(a: U16, b: U16, c: U16): Bool 2 | Bool.and(U16.lte(a, b), U16.lte(b, c)) -------------------------------------------------------------------------------- /src/U16/concat.fm: -------------------------------------------------------------------------------- 1 | U16.concat(a: U16, b: U16): U32 2 | open a 3 | open b 4 | U32.new(Word.concat!!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/div.fm: -------------------------------------------------------------------------------- 1 | U16.div(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.div!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/eql.fm: -------------------------------------------------------------------------------- 1 | U16.eql(a: U16, b: U16): Bool 2 | open a 3 | open b 4 | Word.eql!(a.value, b.value) -------------------------------------------------------------------------------- /src/U16/gte.fm: -------------------------------------------------------------------------------- 1 | U16.gte(a: U16, b: U16): Bool 2 | open a 3 | open b 4 | Word.gte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U16/gtn.fm: -------------------------------------------------------------------------------- 1 | U16.gtn(a: U16, b: U16): Bool 2 | open a 3 | open b 4 | Word.gtn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U16/inc.fm: -------------------------------------------------------------------------------- 1 | U16.inc(a: U16): U16 2 | open a 3 | U16.new(Word.inc!(a.value)) -------------------------------------------------------------------------------- /src/U16/lte.fm: -------------------------------------------------------------------------------- 1 | U16.lte(a: U16, b: U16): Bool 2 | open a 3 | open b 4 | Word.lte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U16/ltn.fm: -------------------------------------------------------------------------------- 1 | U16.ltn(a: U16, b: U16): Bool 2 | open a 3 | open b 4 | Word.ltn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U16/mod.fm: -------------------------------------------------------------------------------- 1 | U16.mod(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.mod!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/mul.fm: -------------------------------------------------------------------------------- 1 | U16.mul(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.mul!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/or.fm: -------------------------------------------------------------------------------- 1 | U16.or(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.or!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/pow.fm: -------------------------------------------------------------------------------- 1 | U16.pow(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.pow!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/shl.fm: -------------------------------------------------------------------------------- 1 | U16.shl(n: U16, a: U16): U16 2 | U16.shl(n, a) -------------------------------------------------------------------------------- /src/U16/show_hex.fm: -------------------------------------------------------------------------------- 1 | U16.show_hex(a: U16): String 2 | open a 3 | Nat.to_string_base(16, Bits.to_nat(Word.to_bits<16>(a.value))) -------------------------------------------------------------------------------- /src/U16/shr.fm: -------------------------------------------------------------------------------- 1 | U16.shr(n: U16, a: U16): U16 2 | U16.shl(n, a) -------------------------------------------------------------------------------- /src/U16/sub.fm: -------------------------------------------------------------------------------- 1 | U16.sub(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.sub!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/to_bits.fm: -------------------------------------------------------------------------------- 1 | U16.to_bits(a: U16): Bits 2 | open a 3 | Word.to_bits<16>(a.value) -------------------------------------------------------------------------------- /src/U16/to_u32.fm: -------------------------------------------------------------------------------- 1 | U16.to_u32(a: U16): U32 2 | open a 3 | U32.new(Word.trim<16>(32, a.value)) -------------------------------------------------------------------------------- /src/U16/to_word.fm: -------------------------------------------------------------------------------- 1 | U16.to_word(a: U16): Word(16) 2 | open a 3 | a.value -------------------------------------------------------------------------------- /src/U16/xor.fm: -------------------------------------------------------------------------------- 1 | U16.xor(a: U16, b: U16): U16 2 | open a 3 | open b 4 | U16.new(Word.xor!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U16/zero.fm: -------------------------------------------------------------------------------- 1 | U16.zero: U16 2 | U16.new(Word.zero(16)) -------------------------------------------------------------------------------- /src/U256.fm: -------------------------------------------------------------------------------- 1 | type U256 { 2 | new(value: Word(256)) 3 | } 4 | -------------------------------------------------------------------------------- /src/U256/0.fm: -------------------------------------------------------------------------------- 1 | U256.0: U256 2 | U256.new(Word.zero(256)) -------------------------------------------------------------------------------- /src/U32.fm: -------------------------------------------------------------------------------- 1 | type U32 { 2 | new(value: Word(32)) 3 | } 4 | -------------------------------------------------------------------------------- /src/U32/add.fm: -------------------------------------------------------------------------------- 1 | U32.add(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.add!(a.value, b.value)) 5 | -------------------------------------------------------------------------------- /src/U32/and.fm: -------------------------------------------------------------------------------- 1 | U32.and(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.and!(a.value, b.value)) 5 | -------------------------------------------------------------------------------- /src/U32/div.fm: -------------------------------------------------------------------------------- 1 | U32.div(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.div!(a.value, b.value)) 5 | -------------------------------------------------------------------------------- /src/U32/eql.fm: -------------------------------------------------------------------------------- 1 | U32.eql(a: U32, b: U32): Bool 2 | open a 3 | open b 4 | Word.eql!(a.value, b.value) -------------------------------------------------------------------------------- /src/U32/for.fm: -------------------------------------------------------------------------------- 1 | U32.for(state: S, from: U32, til: U32, func: U32 -> S -> S): S 2 | case U32.eql(from, til){ 3 | true : state 4 | false: U32.for(func(from, state), U32.inc(from), til, func) 5 | } -------------------------------------------------------------------------------- /src/U32/gte.fm: -------------------------------------------------------------------------------- 1 | U32.gte(a: U32, b: U32): Bool 2 | open a 3 | open b 4 | Word.gte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U32/gtn.fm: -------------------------------------------------------------------------------- 1 | U32.gtn(a: U32, b: U32): Bool 2 | open a 3 | open b 4 | Word.gtn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U32/inc.fm: -------------------------------------------------------------------------------- 1 | U32.inc(a: U32): U32 2 | open a 3 | U32.new(Word.inc!(a.value)) -------------------------------------------------------------------------------- /src/U32/length.fm: -------------------------------------------------------------------------------- 1 | U32.length(str: String): U32 2 | U32.length(str) -------------------------------------------------------------------------------- /src/U32/lte.fm: -------------------------------------------------------------------------------- 1 | U32.lte(a: U32, b: U32): Bool 2 | open a 3 | open b 4 | Word.lte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U32/ltn.fm: -------------------------------------------------------------------------------- 1 | U32.ltn(a: U32, b: U32): Bool 2 | open a 3 | open b 4 | Word.ltn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U32/mod.fm: -------------------------------------------------------------------------------- 1 | U32.mod(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.mod!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U32/mul.fm: -------------------------------------------------------------------------------- 1 | U32.mul(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.mul!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U32/needed_depth.fm: -------------------------------------------------------------------------------- 1 | U32.needed_depth(size: U32): Nat 2 | U32.needed_depth.go(U32.sub(size, 1u)) 3 | -------------------------------------------------------------------------------- /src/U32/needed_depth/go.fm: -------------------------------------------------------------------------------- 1 | U32.needed_depth.go(n: U32): Nat 2 | case U32.eql(n, 0u){ 3 | true : 0 4 | false: Nat.succ(U32.needed_depth.go(U32.shr(n,1u))) 5 | } 6 | -------------------------------------------------------------------------------- /src/U32/or.fm: -------------------------------------------------------------------------------- 1 | U32.or(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.or!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U32/pow.fm: -------------------------------------------------------------------------------- 1 | U32.pow(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.pow!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U32/read_base.fm: -------------------------------------------------------------------------------- 1 | U32.read_base(base: U32, str: String): U32 2 | U32.read_base(base, str) 3 | -------------------------------------------------------------------------------- /src/U32/shl.fm: -------------------------------------------------------------------------------- 1 | U32.shl(n: U32, a: U32): U32 2 | U32.shl(n, a) -------------------------------------------------------------------------------- /src/U32/shr.fm: -------------------------------------------------------------------------------- 1 | U32.shr(n: U32, a: U32): U32 2 | U32.shr(n, a) -------------------------------------------------------------------------------- /src/U32/slice.fm: -------------------------------------------------------------------------------- 1 | U32.slice(i: U32, j: U32, str: String): String 2 | U32.slice(i, j, str) -------------------------------------------------------------------------------- /src/U32/sub.fm: -------------------------------------------------------------------------------- 1 | U32.sub(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.sub!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U32/to_bits.fm: -------------------------------------------------------------------------------- 1 | U32.to_bits(a: U32): Bits 2 | open a 3 | Word.to_bits!(a.value) -------------------------------------------------------------------------------- /src/U32/to_f64.fm: -------------------------------------------------------------------------------- 1 | U32.to_f64(a: U32): F64 2 | U32.to_f64(a) -------------------------------------------------------------------------------- /src/U32/to_nat.fm: -------------------------------------------------------------------------------- 1 | U32.to_nat(a: U32): Nat 2 | open a 3 | Word.to_nat!(a.value) 4 | -------------------------------------------------------------------------------- /src/U32/to_string.fm: -------------------------------------------------------------------------------- 1 | U32.to_string(n: U32): String 2 | Nat.to_string_base(10, U32.to_nat(n)) -------------------------------------------------------------------------------- /src/U32/xor.fm: -------------------------------------------------------------------------------- 1 | U32.xor(a: U32, b: U32): U32 2 | open a 3 | open b 4 | U32.new(Word.xor!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U32/zero.fm: -------------------------------------------------------------------------------- 1 | U32.zero: U32 2 | U32.new(Word.zero(32)) -------------------------------------------------------------------------------- /src/U64.fm: -------------------------------------------------------------------------------- 1 | type U64 { 2 | new(value: Word(64)) 3 | } 4 | -------------------------------------------------------------------------------- /src/U64/add.fm: -------------------------------------------------------------------------------- 1 | U64.add(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.add!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/and.fm: -------------------------------------------------------------------------------- 1 | U64.and(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.and!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/div.fm: -------------------------------------------------------------------------------- 1 | U64.div(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.div!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/eql.fm: -------------------------------------------------------------------------------- 1 | U64.eql(a: U64, b: U64): Bool 2 | open a 3 | open b 4 | Word.eql!(a.value, b.value) -------------------------------------------------------------------------------- /src/U64/gte.fm: -------------------------------------------------------------------------------- 1 | U64.gte(a: U64, b: U64): Bool 2 | open a 3 | open b 4 | Word.gte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U64/gtn.fm: -------------------------------------------------------------------------------- 1 | U64.gtn(a: U64, b: U64): Bool 2 | open a 3 | open b 4 | Word.gtn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U64/inc.fm: -------------------------------------------------------------------------------- 1 | U64.inc(a: U64): U64 2 | open a 3 | U64.new(Word.inc!(a.value)) -------------------------------------------------------------------------------- /src/U64/lte.fm: -------------------------------------------------------------------------------- 1 | U64.lte(a: U64, b: U64): Bool 2 | open a 3 | open b 4 | Word.lte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U64/ltn.fm: -------------------------------------------------------------------------------- 1 | U64.ltn(a: U64, b: U64): Bool 2 | open a 3 | open b 4 | Word.ltn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U64/mod.fm: -------------------------------------------------------------------------------- 1 | U64.mod(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.mod!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/mul.fm: -------------------------------------------------------------------------------- 1 | U64.mul(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.mul!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/or.fm: -------------------------------------------------------------------------------- 1 | U64.or(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.or!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/pow.fm: -------------------------------------------------------------------------------- 1 | U64.pow(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.pow!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/shl.fm: -------------------------------------------------------------------------------- 1 | U64.shl(n: U32, a: U64): U64 2 | U64.shl(n, a) -------------------------------------------------------------------------------- /src/U64/shr.fm: -------------------------------------------------------------------------------- 1 | U64.shr(n: U64, a: U64): U64 2 | U64.shr(n, a) -------------------------------------------------------------------------------- /src/U64/sub.fm: -------------------------------------------------------------------------------- 1 | U64.sub(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.sub!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/to_bits.fm: -------------------------------------------------------------------------------- 1 | U64.to_bits(a: U64): Bits 2 | open a 3 | Word.to_bits!(a.value) -------------------------------------------------------------------------------- /src/U64/xor.fm: -------------------------------------------------------------------------------- 1 | U64.xor(a: U64, b: U64): U64 2 | open a 3 | open b 4 | U64.new(Word.xor!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U64/zero.fm: -------------------------------------------------------------------------------- 1 | U64.zero: U64 2 | U64.new(Word.zero(64)) -------------------------------------------------------------------------------- /src/U8.fm: -------------------------------------------------------------------------------- 1 | type U8 { 2 | new(value: Word(8)) 3 | } 4 | -------------------------------------------------------------------------------- /src/U8/add.fm: -------------------------------------------------------------------------------- 1 | U8.add(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.add!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/and.fm: -------------------------------------------------------------------------------- 1 | U8.and(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.and!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/concat.fm: -------------------------------------------------------------------------------- 1 | U8.concat(a: U8, b: U8): U16 2 | open a 3 | open b 4 | U16.new(Word.concat!!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/div.fm: -------------------------------------------------------------------------------- 1 | U8.div(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.div!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/eql.fm: -------------------------------------------------------------------------------- 1 | U8.eql(a: U8, b: U8): Bool 2 | open a 3 | open b 4 | Word.eql!(a.value, b.value) -------------------------------------------------------------------------------- /src/U8/gte.fm: -------------------------------------------------------------------------------- 1 | U8.gte(a: U8, b: U8): Bool 2 | open a 3 | open b 4 | Word.gte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U8/gtn.fm: -------------------------------------------------------------------------------- 1 | U8.gtn(a: U8, b: U8): Bool 2 | open a 3 | open b 4 | Word.gtn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U8/inc.fm: -------------------------------------------------------------------------------- 1 | U8.inc(a: U8): U8 2 | open a 3 | U8.new(Word.inc!(a.value)) -------------------------------------------------------------------------------- /src/U8/lte.fm: -------------------------------------------------------------------------------- 1 | U8.lte(a: U8, b: U8): Bool 2 | open a 3 | open b 4 | Word.lte!(a.value, b.value) -------------------------------------------------------------------------------- /src/U8/ltn.fm: -------------------------------------------------------------------------------- 1 | U8.ltn(a: U8, b: U8): Bool 2 | open a 3 | open b 4 | Word.ltn!(a.value, b.value) -------------------------------------------------------------------------------- /src/U8/mod.fm: -------------------------------------------------------------------------------- 1 | U8.mod(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.mod!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/mul.fm: -------------------------------------------------------------------------------- 1 | U8.mul(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.mul!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/or.fm: -------------------------------------------------------------------------------- 1 | U8.or(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.or!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/pow.fm: -------------------------------------------------------------------------------- 1 | U8.pow(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.pow!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/shl.fm: -------------------------------------------------------------------------------- 1 | U8.shl(n: U32, a: U8): U8 2 | U8.shl(n, a) -------------------------------------------------------------------------------- /src/U8/shr.fm: -------------------------------------------------------------------------------- 1 | U8.shr(n: U8, a: U8): U8 2 | U8.shr(n, a) -------------------------------------------------------------------------------- /src/U8/sub.fm: -------------------------------------------------------------------------------- 1 | U8.sub(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.sub!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/to_bits.fm: -------------------------------------------------------------------------------- 1 | U8.to_bits(a: U8): Bits 2 | open a 3 | Word.to_bits!(a.value) -------------------------------------------------------------------------------- /src/U8/xor.fm: -------------------------------------------------------------------------------- 1 | U8.xor(a: U8, b: U8): U8 2 | open a 3 | open b 4 | U8.new(Word.xor!(a.value, b.value)) -------------------------------------------------------------------------------- /src/U8/zero.fm: -------------------------------------------------------------------------------- 1 | U8.zero: U8 2 | U8.new(Word.zero(8)) -------------------------------------------------------------------------------- /src/Unit.fm: -------------------------------------------------------------------------------- 1 | type Unit { 2 | new 3 | } 4 | -------------------------------------------------------------------------------- /src/Unit/show.fm: -------------------------------------------------------------------------------- 1 | Unit.show(u: Unit): String 2 | "Unit.new" -------------------------------------------------------------------------------- /src/Vector.fm: -------------------------------------------------------------------------------- 1 | type Vector ~ (size: Nat) { 2 | nil ~ (size: Nat.zero), 3 | ext(head: A, tail: Vector(A,size)) ~ (size: Nat.succ(size)), 4 | } 5 | -------------------------------------------------------------------------------- /src/Vector/from_list.fm: -------------------------------------------------------------------------------- 1 | Vector.from_list(xs: List(A)): Vector(A, List.length(xs)) 2 | case xs { 3 | nil : Vector.nil 4 | cons : Vector.ext(_, xs.head, Vector.from_list(xs.tail)) 5 | }! -------------------------------------------------------------------------------- /src/Vector/head.fm: -------------------------------------------------------------------------------- 1 | Vector.head(vector: Vector(A, Nat.succ(size))): A 2 | case vector { 3 | nil: Unit.new 4 | ext: vector.head 5 | }: case vector.size { zero: Unit, succ: A } -------------------------------------------------------------------------------- /src/Vector/main.fm: -------------------------------------------------------------------------------- 1 | Vector.main: Nat 2 | Vector.head(Vector.from_list([1, 2, 3])) -------------------------------------------------------------------------------- /src/Vector/tail.fm: -------------------------------------------------------------------------------- 1 | Vector.tail(vector: Vector(A, Nat.succ(size))): Vector(A, size) 2 | case vector { 3 | nil: Unit.new 4 | ext: vector.tail 5 | }: case vector.size { zero: Unit, succ: Vector(A, Nat.pred(vector.size)) } -------------------------------------------------------------------------------- /src/Word.fm: -------------------------------------------------------------------------------- 1 | type Word ~ (size: Nat) { 2 | e ~ (size: Nat.zero), 3 | o(pred: Word(size)) ~ (size: Nat.succ(size)), 4 | i(pred: Word(size)) ~ (size: Nat.succ(size)), 5 | } 6 | -------------------------------------------------------------------------------- /src/Word/add.fm: -------------------------------------------------------------------------------- 1 | Word.add(a: Word(size), b: Word(size)): Word(size) 2 | Word.adder(a)(b)(Bool.false) 3 | -------------------------------------------------------------------------------- /src/Word/and.fm: -------------------------------------------------------------------------------- 1 | Word.and(a: Word(size), b: Word(size)): Word(size) 2 | Word.and(a,b) -------------------------------------------------------------------------------- /src/Word/btw.fm: -------------------------------------------------------------------------------- 1 | Word.btw(a: Word(size), b: Word(size), c: Word(size)): Bool 2 | Bool.and(Word.lte(a, b), Word.lte(b, c)) -------------------------------------------------------------------------------- /src/Word/cmp.fm: -------------------------------------------------------------------------------- 1 | Word.cmp(a: Word(size), b: Word(size)): Cmp 2 | Word.cmp.go(a, b, Cmp.eql) -------------------------------------------------------------------------------- /src/Word/div.fm: -------------------------------------------------------------------------------- 1 | Word.div(a: Word(size), b: Word(size)): Word(size) 2 | Word.div(a,b) -------------------------------------------------------------------------------- /src/Word/eql.fm: -------------------------------------------------------------------------------- 1 | Word.eql(a: Word(size), b: Word(size)): Bool 2 | Cmp.as_eql(Word.cmp(a, b)) -------------------------------------------------------------------------------- /src/Word/gte.fm: -------------------------------------------------------------------------------- 1 | Word.gte(a: Word(size), b: Word(size)): Bool 2 | Cmp.as_gte(Word.cmp(a, b)) -------------------------------------------------------------------------------- /src/Word/gtn.fm: -------------------------------------------------------------------------------- 1 | Word.gtn(a: Word(size), b: Word(size)): Bool 2 | Cmp.as_gtn(Word.cmp(a, b)) -------------------------------------------------------------------------------- /src/Word/inc.fm: -------------------------------------------------------------------------------- 1 | Word.inc(word: Word(size)): Word(size) 2 | case word { 3 | e: Word.e, 4 | o: Word.i(word.pred), 5 | i: Word.o(Word.inc(word.pred)) 6 | } : Word(word.size) -------------------------------------------------------------------------------- /src/Word/lte.fm: -------------------------------------------------------------------------------- 1 | Word.lte(a: Word(size), b: Word(size)): Bool 2 | Cmp.as_lte(Word.cmp(a, b)) -------------------------------------------------------------------------------- /src/Word/ltn.fm: -------------------------------------------------------------------------------- 1 | Word.ltn(a: Word(size), b: Word(size)): Bool 2 | Cmp.as_ltn(Word.cmp(a, b)) -------------------------------------------------------------------------------- /src/Word/mod.fm: -------------------------------------------------------------------------------- 1 | Word.mod(a: Word(size), b: Word(size)): Word(size) 2 | Word.mod(a,b) -------------------------------------------------------------------------------- /src/Word/mul.fm: -------------------------------------------------------------------------------- 1 | Word.mul(a: Word(size), b: Word(size)): Word(size) 2 | Word.mul(a,b) -------------------------------------------------------------------------------- /src/Word/nat_log2.fm: -------------------------------------------------------------------------------- 1 | Word.nat_log2(word: Word(size)): Nat 2 | Word.nat_log2.go(word, 0, 0) -------------------------------------------------------------------------------- /src/Word/nat_log2/go.fm: -------------------------------------------------------------------------------- 1 | Word.nat_log2.go(word: Word(size), c: Nat, n: Nat): Nat 2 | case word { 3 | e: n 4 | o : Word.nat_log2.go(word.pred, Nat.succ(c), n) 5 | i : Word.nat_log2.go(word.pred, Nat.succ(c), c) 6 | } -------------------------------------------------------------------------------- /src/Word/or.fm: -------------------------------------------------------------------------------- 1 | Word.or(a: Word(size), b: Word(size)): Word(size) 2 | Word.or(a,b) -------------------------------------------------------------------------------- /src/Word/pow.fm: -------------------------------------------------------------------------------- 1 | Word.pow(a: Word(size), b: Word(size)): Word(size) 2 | Word.pow(a, b) -------------------------------------------------------------------------------- /src/Word/pred.fm: -------------------------------------------------------------------------------- 1 | Word.pred(word: Word(Nat.succ(size))): Word(size) 2 | case word { 3 | e: Word.e, 4 | o : word.pred, 5 | i : word.pred 6 | } : Word(Nat.pred(word.size)) -------------------------------------------------------------------------------- /src/Word/reverse.fm: -------------------------------------------------------------------------------- 1 | Word.reverse(word: Word(size)): Word(size) 2 | def nil = Word.e 3 | def w0 = (rev) Word.o(rev) 4 | def w1 = (rev) Word.i(rev) 5 | Word.foldl(nil, w0, w1, word) -------------------------------------------------------------------------------- /src/Word/shift_left.fm: -------------------------------------------------------------------------------- 1 | Word.shift_left: -> Nat -> Word(size) -> Word(size) 2 | Word.shift_left -------------------------------------------------------------------------------- /src/Word/shift_right.fm: -------------------------------------------------------------------------------- 1 | Word.shift_right: -> Nat -> Word(size) -> Word(size) 2 | Word.shift_right -------------------------------------------------------------------------------- /src/Word/sub.fm: -------------------------------------------------------------------------------- 1 | Word.sub(a: Word(size), b: Word(size)): Word(size) 2 | Word.subber(a, b, Bool.false) -------------------------------------------------------------------------------- /src/Word/to_bits.fm: -------------------------------------------------------------------------------- 1 | Word.to_bits(a: Word(size)): Bits 2 | case a { 3 | e: Bits.e, 4 | o: Bits.o(Word.to_bits(a.pred)), 5 | i: Bits.i(Word.to_bits(a.pred)), 6 | } -------------------------------------------------------------------------------- /src/Word/to_nat.fm: -------------------------------------------------------------------------------- 1 | Word.to_nat(word: Word(size)): Nat 2 | Word.fold<(x) Nat, size>(0, <_> Nat.mul(2), <_> (x) Nat.succ(Nat.mul(2, x)), word) 3 | -------------------------------------------------------------------------------- /src/Word/xor.fm: -------------------------------------------------------------------------------- 1 | Word.xor(a: Word(size), b: Word(size)): Word(size) 2 | Word.xor(a, b) -------------------------------------------------------------------------------- /src/Word/zero.fm: -------------------------------------------------------------------------------- 1 | Word.zero(size: Nat): Word(size) 2 | case size { 3 | zero: Word.e, 4 | succ: Word.o(Word.zero(size.pred)) 5 | } : Word(size) -------------------------------------------------------------------------------- /web/src/apps/index.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | 'Web.Demo': import('./Web.Demo.js'), 3 | } 4 | -------------------------------------------------------------------------------- /web/src/assets/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moonad/Formality-tmp/8ef7d8ef9c70d51e295c4b11e36c0882d6bfde75/web/src/assets/favicon.ico -------------------------------------------------------------------------------- /web/src/assets/moonad_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moonad/Formality-tmp/8ef7d8ef9c70d51e295c4b11e36c0882d6bfde75/web/src/assets/moonad_logo.png -------------------------------------------------------------------------------- /web/src/assets/moonad_logo_white.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moonad/Formality-tmp/8ef7d8ef9c70d51e295c4b11e36c0882d6bfde75/web/src/assets/moonad_logo_white.png --------------------------------------------------------------------------------