There are a few I’m aware of:

  1. Rust-style use (multiple imports per statement, renaming items using as)
  2. Java-style import (single import per statement, no renaming (afaik))
  3. Zig-style let xlib = @import("xlib") (imports as assignments)
  4. C-style #include (no importing, just pastes the code of the named file)
  • nebeker@programming.devEnglish
    16·
    17 days ago

    I think C# handles this pretty well. You include namespaces with whatever granularity you need, down to a single class (or interface or whatever) and can alias them.

    using MyProject.Domian.Entities; //the whole module
using Routes = MyProject.Api.Contract.Routes.Http;  //an aliased single class

    I bet Java had this too, C# us still mostly Java: Microsoft Edition.

    • Kwdg@discuss.tchncs.de
      3·
      17 days ago

      It’s actually pretty similar to rust, only that rust can import multiple modules (namespaces) in one line, which is just syntax sugar, and the syntax is slightly different.

      Your example would be

      use my_projext::domain::entities;
use my_project::api::contracts::routes::http as routes;
      • nebeker@programming.devEnglish
        1·
        17 days ago

        Rust adds the curly brace syntax so you can import a specific subset from a module, but I can’t decide if I like that. In C# you just keep adding extra lines which take up more vertical space, but if you sort your using a alphabetically (which your IDE can do), I think you get a very readable list. In sum, Rust adds a feature that I don’t really actually like.

    • terabyterex@lemmy.world
      3·
      17 days ago

      c# is delphi with some realized mfc lofty goals.

      first, microsoft liked delphi and hired the guy who created delphi to create c#

      second if you read an mfc book from the 90s that talks about history and goals, 6ou can see they wanted the .net framework

      • nebeker@programming.devEnglish
        1·
        14 days ago

        You know, I don’t know enough about Delphi. I’ve great good things, I should check it out, I guess it might be familiar.

  • cosmicrose@lemmy.blahaj.zoneEnglish
    16·
    17 days ago

    I like Rust’s style. It’s simple and it does everything you need. As much as I love Elixir, which I write at my day job, it has alias, import, use, and require, which each import things different, and it can get a bit confusing.

  • FizzyOrange@programming.dev
    12·
    17 days ago

    In order or preference, out of the ones I’m familiar with:

    1. Java. Very simple. Diff friendly. Import names match the filesystem.
    2. Rust. Also good - you can do it diff friendly though nobody does. Slightly confusing distinction between module hierarchy and filesystem.
    3. Python. Pretty bad. Conflates third party packages with local files, almost nobody actually understands relative imports, even more confusing distinction between module hierarchy and filesystem. Module imports can have side effects. Unnecessarily different syntax between import... and from .... import....
    4. C/C++. Obviously this is the worst.
    • kureta@lemmy.ml
      6·
      16 days ago

      Well, I have been using python for a long time and was ready to disagree with you but damn, it really do be like that.

  • TootSweet@lemmy.worldEnglish
    7·
    17 days ago

    I suspect most developers have a “favorite language” and are just going to respond with “the import style my favorite language uses”.

  • DNEAVES@lemmy.world
    7·
    16 days ago

    Elm:

    -- Import under the name "List"
import List

-- Import aliased under the name "JD"
import Json.Decode as JD

-- Import Html, and put the Html type into the unqualified namespace
import Html exposing (Html)

-- Import Http, and put everything from it in the unqualified namespace
import Http exposing (..)
  • MyNameIsRichard@lemmy.ml
    61·
    17 days ago

    I’m most used to c style and as a result I like it because it’s simple and uncomplicated. I recently started learning rust and quite like their way of doing it, although there’s also mod and I haven’t quite figured out when to use which. I just do what rust analyser tells me :)

  • h54@programming.dev
    4·
    17 days ago

    I like being able to import multiple things from a given package/module on the same line. Aliasing is also very useful.

  • GarboDog@lemmy.world
    4·
    17 days ago

    Like to import via smuggli- OH we’re talking about coding? Uhh Java does it pretty well and we’re learning C# rn so gonna have to learn how to import that soon

  • Alavi@programming.dev
    4·
    17 days ago

    Zig and Rust are good. Java is painful.

    But the best for me is Clojure:

    (require [my.module :refer [func1 func2]]
               [Some.lib :as lib])