Add lints detected in fp2020/2021/2022/2023 programming course

[ ] Exposed public functions but not used anywhere.
[ ] match ... with _ as x -> ....
[ ] Algebraic data types
- [ ] With single constructor
- [x] #26 and jump_stmt = None | Break | Continue | Return of v_value
- [ ] Naming: capitalized snake case looks weird
- [ ] Warn about type names with quotes.
[ ] Booleans
- [x] An action that panics on if true then ...
- [x] if ... then true else false
[ ] Strings
- [x] Expression ... ^ ... ^ ... may not be efficient

[ ] Matching

[ ] | Foo x when x = true -> ... ~~~> | Foo true -> ....

[x] #13

 match scru with 
 | (a,b) -> rhs

into

 let (a,b) = scru in rhs

[ ] Match on bool when scrutinee starts with not

  match not (if_object (get_var_ctx_from_ctx i env).value) with
        | true -> ....        
        | false -> ....

[x] Rewrite fun e -> match e with ... to function ... if possible
- [ ] Propose function here too
```
(fun l ->
match l with
| [ ty ] -> ty
| _ -> t_tuple l)
```
[ ] #27
[ ] | Return rexpr_o -> ( match rexpr_o with ... )
[ ] Recommend or-patterns when possible

[ ] Detect same RHSes

 match MapString.find_opt id env9 with
 | None -> return (MapString.add id v env9)
 | Some _ -> return (MapString.add id v env9) in

See also #42

[ ] Recommend nested matching

    | EConst x ->
      (match x with
      | CInt _ -> return (Subst.empty, TInt)
      | CBool _ -> return (Subst.empty, TBool)
      | CString _ -> return (Subst.empty, TString))

      match stmts with
      | s :: st -> (
          match s with
          | RETURN ret_e -> (
              match ret_e with
              | LITERAL CVOID -> is_correct_void st (r && true)
              | _ -> is_correct_void st (r && false))
          | _ -> is_correct_void st r)
      | _ -> r

match n with
| "malloc" -> (
    match vals with
    | ...)
| "free" -> (
    match vals with
    | ...)
| "sizeof" -> (
    match vals with
    | ...)
| "main" -> ...

[ ] Exceptions
- [x] failwith
- [ ] Using of List.hd_exn may be error-prone
- [ ] Matching with _ exception
- [x] Catching Failure _ exception
- [ ] Suggest function name with _exn suffix when function can throw an exception.
[ ] Records
- [x] #10
- [ ] Rewrite { key = fkey; foo = _; bar = _ } to { key = fkey; _ }
- [ ] Rewrite '{ field=field; ... }' but maybe it is not possible and ocamlformat should do it
  - [ ] Propose record punning (???)
```
let add_func_in_ctx i a s ctx =
 { ctx with funcs = { id = i; args = a; stmts = s } :: ctx.funcs }
```
  - [ ] Discourage clashing fields, which require explicit type annotation
```
type var_ctx =
{ id : id
; value : value
}

type func_ctx =
{ id : id
; args : id list
; stmts : statement list
}
```

[ ] Monads

[ ] Adding stuff to Monad signature that doesn't belong there

[ ] Propose applicatives

        ac >>= fun ac ->
        to_type ctx v >>= fun t -> return @@ (t :: ac))

[ ] #48

let* env, typ = check_type env hd in
    return (env, typ)

  let new_res = ln ^ Printf.sprintf "%s -> %s " k (exval_to_str v) in
  new_res

[x] #53

[x] #46

        let rec go acc =
          lift2 (fun f x -> f acc x) op (choice [ pl >>= go; pr ]) <|> return acc
        in
        pl >>= go

It looks like patterns like (fun arg1...argN -> IDENT arg1 ... argN) suites and only them

[ ] Rewrite '(fun state decl -> eval_dec state decl)' with eta-conversion
[ ] Expressions like ... :: [ ... ] smell bad
[ ] Weird stuff
- [ ] let ctx = ctx in ...
- [ ] return @@ Vchar v we should probably recommend parenthesis
- [ ] simplify >>= fun ident -> return ident and fun (ctx', pls) -> return (ctx', pls)
- [ ] lists
  - [ ] ... :: [ ... ] smells bad
  - [ ] (t' :: ts') @ acc smells bad. Propose t' :: (ts' @ ac)
[ ] Parser-combinator stuff:
- [ ] Simplify 'token "#" >> token "#"'
[ ] Global mutable variables
- [ ] adding [@@deriving sexp] introduce code with assignments.
[x] Warn when value's name has starting '_' but used elsewhere
[ ] Detect functions that not used
[ ] Ignore without specifying type of ignored variable
- [x] ignore as last expression of function (which doesn't really ignore anything)
- [ ] maybe restrict ignoring of monadic values
[ ] Detect functions already present in Stdlib and Base. Maybe only declared as structure items.
- [ ] The same for exceptions
- [ ] In worst case detect functions that look like standard list functions: map and fold
[ ] Rewrite common idiom
- [x] 'concat' + 'map' => concat_map
- [x] 'filter' + 'map' => filter_map
- [ ] List.to_seq [ eff ] => Seq.return eff
- [ ] etc...
[x] ~~Rewrite fun cd -> let f ... = (* no use of cd *) in ... to let f ... = ... in fun cd -> ...~~
[x] Toplevel print_string ... should be let () = ...
[ ] Лишние @@ в return @@ Nil
- [ ] Не очень понятно как детектировать гадости типа return @@ (x+y)
- [ ] Но вот тут понятно как: return @@ (get_var_ctx_from_ctx i e_env).value
[x] Mutable variables never assigned
[x] #17
- [ ] #47
- [ ] even for
```
type value
and r_ok
and r_err
```
[ ] Copypaste detection
[ ] Propose string literals as {| ... |} when a normal string literal has too many '\n'
[ ] cram tests
- [ ] Detect errornously disabled test (no two spaces in the beginning)
- [ ] recommend (cram (deps ....)
[ ] (fun (ptrn, _) -> ptrn) -> fst

[ ] shorten

 let add map k v =
  match Map.add map ~key:k ~data:v with
  ...

Kakadu / zanuda

Add lints detected in fp2020/2021/2022/2023 programming course #3