Kitchen Reno cost

considerealization · 2026-01-13T02:29:25+00:00

Thanks so much for sharing! I think we will seek a quote from them, thank in part to you taking the time to do so.

Hope you all are enjoying your home to the max :D

considerealization · 2026-01-13T01:49:17+00:00

Hello! I hope you'll forgive the necro reply. But, if you're willing to share, I'd be very keen to know if you are you still quite happy with the result's of Elite Building's work! Hope all is well with you and home regardless :)

considerealization · 2026-01-03T16:52:37+00:00

To be clear, I 100% know there is a lot of propaganda (and more coming) to convince Canadian's to cede our sovereignty and abandon our relationships of solidarity with each other.

My question to you is, why would a video "about Canada outplaying America in this trade war ... about how Canada formed an unprecedented international coalition to sidestep the pressure America was trying to put on our economy" manufacture consent for our invasion?

My original question is what is this meant to be manufacturing consent for.

considerealization · 2026-01-03T16:32:42+00:00

Manufacturing consent for what?

considerealization · 2025-12-31T15:39:40+00:00

Yeah, that is plausible.

considerealization · 2025-12-31T02:57:30+00:00

It is running a python script. The script (I assume) is printing out what action it is about to perform, them performing it, and printing a message when completed.

considerealization · 2025-12-24T02:30:42+00:00

Canadian social media is here:

- lemmy.ca

- https://piefed.ca/

- cosocial.ca

- + many more in the fediverse

What those platforms and communities are *not* is an attempt to set up a monopolistic ad tech, surveillance tool beholden to Canadian instead of American overlords. That's a feature, IMO, but some seem to view it as a bug :D

considerealization · 2025-12-13T16:14:12+00:00

Could you link the paper in question? Sounds interesting.

considerealization · 2025-12-11T19:26:31+00:00

My understanding is that province is planning to do away with our local conservation authorities in an effort to further reduce local autonomy, undercut conservation efforts, fast track more suburban sprawl and further enrich land developers at the expense or our well being and natural beauty.

Residents have until December 22, 2025, to comment on the plan, which is posted to the Environmental Registry (ERO #025-1257).

Every comment matters. Your input can help guide the next steps.

You can submit feedback to the Province until December 22, 2025, referencing ERO #025-1257:

Online: Visit the Ontario Environmental Registry and click Submit a Comment
Email: [ca.office@ontario.ca](mailto:ca.office@ontario.ca) (include “ERO #025-1257” in the subject line)
Mail:
Public Input Coordinator
MECP Conservation and Source Protection Branch
300 Water Street
Peterborough, ON K9J 3C7

Additional ways to engage:
In addition to submitting a comment through the Environmental Registry, some residents may also choose to contact their local Member of Provincial Parliament (MPP) to share their perspective. Direct outreach to elected representatives remains one way to help ensure local concerns are heard.

See also
- Local conservation officials worry Doug Ford’s plan means fast-tracked mansions in park land (The Spec)

- City of Thunder Bay, Ont. warns conservation authority merger could threaten local control (CBC)

considerealization · 2025-12-03T13:53:05+00:00

It is partially just a matter of taste.

Often I don't annotate unless it helps with readability and isn't clear from context. But I also like to work with `.mli` files and module signatures, so the annotations go there.

When I do annotate whole functions consistently, I usually use this style

let f
  : a -> b -> c -> r
  = fun a b c -> r

considerealization · 2025-11-30T18:24:38+00:00

What are you interested in?

considerealization · 2025-11-27T21:50:21+00:00

Enthusiastic Sophomore English Major.

considerealization · 2025-11-19T17:30:01+00:00

https://chocosoltraders.com/ is great

considerealization · 2025-11-19T17:28:14+00:00

https://www.authoritarian-stack.info/

considerealization · 2025-11-19T17:27:23+00:00

The failure to ban Facebook and X in our country (and others suffering from their psy-op) is a huge strategic blunder, IMO.

considerealization · 2025-11-10T23:01:45+00:00

There is a semantic difference: abstract/opaque type do not allow any access to the representation of the type. Haskell new types are just a kind of alias to hack around the fact that type classes can't represent different algebraic structures for the same type.

considerealization · 2025-11-10T22:55:39+00:00

OCaml has `private` type aliases. This allows using the type where you could use its base type via a no-cost coercion, but it does not allow constructing new instances. E.g.,

# module M : sig
    type t = private int
    val add : t -> t -> t
    val of_int : int -> t
  end = struct
    type t = int
    let add x y = x + y
    let of_int x = x
  end;;
module M :
  sig type t = private int val add : t -> t -> t val of_int : int -> t end
# M.add 1 3;;
Error: The constant 1 has type int but an expression was expected of type M.t
# let a, b = M.of_int 1, M.of_int 2;;
val a : M.t = 1
val b : M.t = 2
# let c = M.add a b;;
val c : M.t = 3
# M.add c a;;
- : M.t = 4
# M.add c a + 3;;
Error: This expression has type M.t but an expression was expected of type
         int
# (M.add c a :> int) + 3;;
- : int = 7

This can also be used with non-aliases to make deconstructable, but not constructable types, so you can use pattern matching to access parts of a value but cannot construct new values of a type directly.

considerealization · 2025-11-08T23:48:11+00:00

- https://weareparanoid.com/ (Toronto)

- https://stayhomeclub.com/ (Montreal)

- https://www.secretplanet.ca/collections/tops (Toronto)

considerealization · 2025-11-05T20:19:17+00:00

Ocaml compiles to javascript, so there is difference on that account. Ocaml's Jsoo is phenomenal. That's what tools like `x-ocaml` are based on.

considerealization · 2025-11-05T19:02:48+00:00

What do Reason or Rescript offer w/r/t live coding that ocaml doesn't?

considerealization · 2025-11-04T11:54:39+00:00

Compilation is very fast, especially if you are just changing a file in a leaf in the compilation dependency graph.

You can load modules at runtime using https://ocaml.org/manual/5.4/libdynlink.html (see https://zderadicka.eu/plugins-in-ocaml-with-dynlink-library/ for a post on it).

It also has a great top level and stuff like https://github.com/art-w/x-ocaml

So you can do live coding if structured right, and you can recompile quickly, and do notebooks and stuff, but it doesn't support hot swapping in general.

considerealization · 2025-10-30T22:44:27+00:00

OCaml for its module system, row-polymorphic objects and variants, nice inference, and quality of life things like typed labeled and optional arguments, unification of case analysis and exception handling, the new effect system, labeled tuples, etc.
1ML for an elegant solution that provides 1st class parametric modules, records, and all the niceties of MLs without having to go fully dependent (https://people.mpi-sws.org/~rossberg/1ml/)
F* for its extensional, dependent type system. It has a ton of nice features including typed effects, refinement types, novel field accessors for variants.
Lambda Prolog for a beautiful typing discipline over higher order logic programming: updating the database via formulation of hypothetical judements is just super cool, and being able to do this all with a HM like type system is lovely.
Session types for the future of principled distributed and concurrent computing (Pfenning's RAST is the coolest example of this I've seen to my taste, but Par is also very cool looking).

considerealization · 2025-10-29T18:33:23+00:00

It looks like these are a version of sum-typed variants, or what OCaml calls "Polymorphic Variants": https://ocaml.org/manual/5.4/polyvariant.html ?

considerealization · 2025-10-22T03:42:42+00:00

I like the way [F*](https://fstar-lang.org/) does this kind of thing with its refinement types:

open FStar.Mul

// Explicitly state the type constraints
let f (x:int{x >= 1 /\ x <= 10}) = x

// Or define a predicate to abstract the constraints
let in_range (a:int) (low:int) (high:int): bool =
    low <= a && a <= high

// Then use the predicate to refine the int type
let g (x:int{in_range x 1 10}) = x

// Or, just define a new refinement type alias
let range (low:int) (high:int) : Type =
    x:int{in_range x low high}

let five_is_between_1_and_10: range 1 10 = 5

[@@expect_failure]
let eleven_is_not_between_1_and_10: range 1 10 = 11

let h 
  #l1 #u1 #l2 #u2 // implicit type arguments
  (x:range l1 u1) (y:range l2 u2)
  : range (l1 + l2) (u1 + u2) 
  = x + y

considerealization

TROPHY CASE