If you're here because you're searching for this problem, I guess we never did make Norm compatible with Dialyzer. Here are some workaround for the errors:

Unknown types: run mix dialyzer --format dialyzer to get the long form and add it to your dialyzer.ignore-warnings eg.:

:0: Unknown type 'Elixir.Norm.Core.AnyOf':t/0

call_with_opaque: add :no_opaque to your flags (documented under Dialyxir's paths heading):

def project do
  [
    dialyzer: [
      ignore_warnings: "dialyzer.ignore-warnings",
      flags: [:no_opaque],
      # ...
end

If you're using ElixirLS you'll need to add the same flag to its options, e.g. in your VS Code settings.json:

{ "elixirLS.dialyzerWarnOpts": [ "no_opaque" ] }

Still feeling too brutal? Need those warnings elsewhere? Add a dialyzer module attribute to suppress those specific warnings:

@dialyzer {:no_opaque, module: 0, function: 0, term: 0}

defguard(is_term(_) when true)

def module, do: with_gen(spec(is_atom()), StreamData.atom(:alias))
def function, do: with_gen(spec(is_atom()), StreamData.atom(:alphanumeric))
def term, do: with_gen(spec(is_term), StreamData.term())
def mfa, do: {module(), function(), coll_of(term(), into: [])}

Maybe I'm missing something but this seems like a pretty innocuous change. So I'm happy to add it if. My main concern is just that we don't run dialyzer in Norm's CI suite. Which means it wouldn't be enforced atm.

I'm pretty comfortable with @dialyzer {:no_opaque, my_spec: 0} now; how about I summarise the @dialyzer module attribute trick under an ## Interoperability with Dialyzer heading in README.md?

That seems great. Feel free to submit a PR.

I've been looking into this more. From what I can tell this is actually a stream_data issue and doesn't have anything to do with Norm. Its also possible that I'm reading this wrong. I added dialyzer to Norm, and added a new module like so:

defmodule Norm.Test do                                                                                                      
  import Norm                                                                                                               
                                                                                                                            
  def foo do                                                                                                                
    with_gen(spec(is_atom), StreamData.atom(:alphanumeric))                                                                 
  end                                                                                                                       
end

After 10,000 years waiting for dialyzer to build a PLT, realizing that stream_data wasn't included in the PLT, reconfiguring and waiting another 10,000 years, dialyzer eventually spits out this error:

lib/norm/core/spec.ex:122:call_without_opaque
Function call without opaqueness type mismatch.

Call does not have expected opaque term of type StreamData.t(_) in the 1st position.

StreamData.map(%StreamData{:generator => (_, _ -> map())}, (_ -> any()))

We're not actually doing anything wrong here. We're just using stream_data's API. I think the issue is that stream_data hasn't added explicit type specs to it's APIs, which it has to do if StreamData.t is opaque.