Conditional import and lexical scope

Imports are compile-time.

Elixir being FP I don’t see any other way except closures or just passing a function like so

defmodule Helper
  if compile_time_condition do
    def with_scope(fun) do
      import Enum
      fun.()
    end
  else
    def with_scope(fun) do
      import Stream
      fun.()
    end
  end
end

Or you can do it with a keyword list parameter with :do and :else like the if macro does.

That’s what I’d do, which seems a lot cleaner than conditionally importing things.

mod = if condition, do: Stream, else: Enum
mod.map(1..integer, &IO.inspect(&1))

This is pretty much what i am doing.
It is for a BackPort module, where I give support for older Elixir versions importing functions/macros based on macro_exported?(Kernel, :macro_name, :arity)

It still baffles me why using && will not work.

macro_exported?(Kernel, :is_struct, 2) && (import BackPort, :is_struct, 2)

I have not read && creating a lexical scope within itself.

The behavior makes sense if you look at the implementation:
https://github.com/elixir-lang/elixir/blob/74bfab8ee271e53d24cb0012b5db1e2a931e0470/lib/elixir/lib/kernel.ex#L3791-L3803

The right-hand expression in && winds up inside a case statement, so the import does not leak out.

@al2o3cr you are so right! I wrongly assumed that it was &&/2 was inlined by the compiler. I guess it all comes down to this, anyway had it been, it would have been the same:

:erlang.andalso(true, (import Enum, only: [map: 2]))
map(1..integer, &IO.inspect(&1))

because this seems to work the same way.

So I guess the only option here is evaluating the condition at compile time.

Thank you all guys for your contributions.