Simon Cruanes c-cube

Python4

We all have in mind the painful transition from python2 to python3. I argue python4 should be a priviledged subset of python3 that is still compatible with it, so that the transition is frictionless. At the same time, python4 should address some of the biggest limitations of python3:

the very low performance
the high memory overhead of default constructs
the GIL
the packaging mess

However, I don't think this can be fixed without breaking everything:

Plans for the future of OCaml's stdlib

One of the most common complaint about OCaml, from both newcomers and veterans, is that the stdlib is lacking in several domains. Among these we can list:

some modules are absent but should exist (e.g. Option)
some modules are present but lack some functionality (e.g. List could have many more combinators)
the lack of some transverse features (iterators, printers, monadic operators…)
the lack of generality of some constructs. Notably, in_channel

	profile=conventional
	margin=80
	if-then-else=fit-or-vertical
	parens-ite=true
	parens-tuple=multi-line-only
	type-decl=sparse
	space-around-collection-expressions=false
	break-cases=toplevel
	cases-exp-indent=2
	leading-nested-match-parens=true


	extern crate rand;

	const N : usize = 1_000_000;
	//const N : usize = 20;

	#[inline(always)]
	fn test_bit(x: u8, bit: u8) -> bool {
	(x & bit) != 0
	}


	type 'a gen = unit -> 'a option

	module Co : sig
	type 'a t (* yields ['a] *)

	val make : 'a t -> 'a gen

	val return : 'a -> 'a t


	(executable
	((name truc)
	(libraries (benchmark))
	(flags (:standard -w +a-4-42-44-48-50-58-32-60@8 -color always))
	(ocamlopt_flags (:standard -O3 -bin-annot
	-unbox-closures -unbox-closures-factor 20))
	))

	Sequence.(1--100
	\|> map (fun n->n,if n mod 3=0 then "fiz" else "")
	\|> map (fun (n,s) -> n, if n mod 5=0 then s^"buzz" else s)
	\|> map (function (n,"") -> string_of_int n\|(_,s) -> s)
	\|> iter print_endline);;

	type t = {
	mutable id: int; (* unique ID *)
	view: view;
	}
	and view =
	\| Const of string
	\| App of t * t

	let equal t u = t.id = u.id
	let hash t = Hashtbl.hash t.id

	#require "bigstring";;
	#require "sequence";;

	(* the goal is to count how many times each character occurs in the file *)

	let file = "foo.txt";;

	(* simple way *)
	Bigstring.with_map_file file
	(fun map ->


	let f l = l <> [(1, "foo"); (2, "bar")] ;;